Lógica matemática y fundamentos (2018-19) - Contribuciones del usuario [es]

Sol 13

2019-06-26T16:02:22Z

Mjoseh:

<source lang = "isabelle">
chapter {* R13: Definiciones inductivas: clausuras *}

theory R13_sol
imports Main
begin

section {* La clausura reflexiva transitiva *}

text {*
· Las definiciones inductivas aceptan parámetros; por tanto, permite
expresar funciones que construyen conjuntos.

· La relaciones binarias son conjuntos de pares; por tanto, se pueden
definir inductivamente.
*}

text {*
· La clausura reflexiva y transitiva de una relación r es la menor
relación reflexiva y transitiva que contiene a r.

· Se representa por r*.

· Se puede definir inductivamente, como conjunto:
· (x,x) ∈ r*
· Si (x,y) ∈ r e (y,z) ∈ r*, entonces (x,z) ∈ r*

· La definición inductiva, como conjunto, se puede expresar en
Isabelle/HOL como sigue:
*}

inductive_set
crt :: "('a × 'a) set ⇒ ('a × 'a) set" ("_*" [1000] 999)
for r :: "('a × 'a) set"
where
crt_refl [iff]: "(x,x) ∈ r*"
| crt_paso: "⟦(x,y) ∈ r; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"

text {*
Notas:
· La sintaxis concreta permite escribir r* en lugar de (crt r).
· La definición consta de dos reglas.
· A la regla reflexiva se le añade el atributo iff para aumentar la
automatización.
· A la regla del paso no se le añade ningún atributo, porque r* ocurre
en la izquierda.
· En el resto de esta sección se demuestra que esta definición
coincide con la menor relación reflexiva y transitiva que contiene a
r.
*}

text {*
Lema. La relación r* es reflexiva.
*}

lemma "(x,x) ∈ r*"
by (rule crt_refl)

text {*
Lema. La relación r* contiene a r.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
apply (erule crt_paso)
(* (y, y) ∈ r**)
apply (rule crt_refl)
(* *)
done

(* La demostración automática es *)
lemma r_contenida_clausura [intro]:
"(x,y) ∈ r ⟹ (x,y) ∈ r*"
by (simp add: crt_paso)
(* by (auto intro: crt_paso) *)

(* La demostración declarativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
proof -
assume 1: "(x, y) ∈ r"
have 2: "(y, y) ∈ r*" by simp
show "(x,y) ∈ r*" using 1 2 by (rule crt_paso)
qed

text {*
Notas:
· La ventaja del lema es que se puede declarar como regla de
introducción, porque r* ocurre sólo en la derecha.
· Con la declaración, algunas demostraciones que usan crt_paso se
hacen de manera automática.
*}

text {*
El esquema de inducción de la clausura reflexiva transitiva es
· crt.induct:
⟦(x1, x2) ∈ r*;
⋀x. P x x;
⋀x y z. ⟦(x,y) ∈ r; (y,z) ∈ r*; P y z⟧ ⟹ P x z⟧
⟹ P x1 x2
*}

text {*
Lema. La relación r* es transitiva.
*}

(* La demostración aplicativa es *)
lemma "⟦(x,y) ∈ r*; (y,z) ∈ r*⟧ ⟹ (x,z) ∈ r*"
apply (induction rule:crt.induct)
(* 1. ⋀x. (x, z) ∈ r* ⟹ (x, z) ∈ r*
2. ⋀x y za. ⟦(x, y) ∈ r; (y, za) ∈ r*;
(za, z) ∈ r* ⟹ (y, z) ∈ r*;
(za, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply simp
(* 1. ⋀x y za. ⟦(x, y) ∈ r; (y, za) ∈ r*;
(za, z) ∈ r* ⟹ (y, z) ∈ r*;
(za, z) ∈ r*⟧
⟹ (x, z) ∈ r**)
apply (simp add: crt_paso)
(* *)
done

lemma "⟦ (x,y) ∈ r*; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"
by (induction rule: crt.induct)
(simp_all add: crt_paso)

text {*
Otra formulación del lema, con la variable y a la derecha.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
apply (induction rule: crt.induct)
(* 1. ⋀x. (x, z) ∈ r* ⟶ (x, z) ∈ r*
2. ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r* ⟶ (y, z) ∈ r*⟧
⟹ (za, z) ∈ r* ⟶ (x, z) ∈ r* *)
apply simp
(* ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r* ⟶ (y, z) ∈ r*⟧
⟹ (za, z) ∈ r* ⟶ (x, z) ∈ r* *)
apply (rule impI)
(* ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r* ⟶ (y, z) ∈ r*;
(za, z) ∈ r*⟧
⟹ (za, z) ∈ r* ⟶ (x, z) ∈ r* *)
apply (drule mp)
(* 1. ⋀x y za. ⟦(x, y) ∈ r; (y, za) ∈ r*; (za, z) ∈ r*⟧
⟹ (za, z) ∈ r*
2. ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r*;
(y, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply assumption
(* ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r*;
(y, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply (erule crt_paso)
(* ⋀x y za. ⟦(y, za) ∈ r*; (za, z) ∈ r*; (y, z) ∈ r*⟧
⟹ (y, z) ∈ r**)
apply assumption
(* *)
done

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
by (induction rule:crt.induct)
(auto simp add: crt_paso)

(* La demostración declarativa es *)
lemma crt_trans [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
proof (induction rule:crt.induct)
show "⋀x. (x,z) ∈ r* ⟶ (x,z) ∈ r*" by simp
next
fix x y u
assume H1: "(x,y) ∈ r" and
H2: "(y,u) ∈ r*" and
H3: "(u,z) ∈ r* ⟶ (y,z) ∈ r*"
show "(u,z) ∈ r* ⟶ (x,z) ∈ r*"
proof
assume "(u,z) ∈ r*"
with H3 have "(y,z) ∈ r*" ..
with H1 show "(x,z) ∈ r*" by (rule crt_paso)
qed
qed

text {*
Notas:
· La reformulación anterior es un caso particular de la siguiente
heurística:
"Para probar una fórmula por inducción sobre (x1,...,xn) ∈ R,
poner todas las premisas conteniendo cualquiera de lax xi en la
conclusión usando ⟶".
· El atributo "rule_format" transforma ⟶ en ⟹.
*}

text {*
La relación r* está contenida en cualquier relación reflexiva y
transitiva que contenga a r.

Mediante (crt2 r) se define la menor relación reflexiva y transitiva
que contiene a r.
*}

inductive_set
crt2 :: "('a × 'a)set ⇒ ('a × 'a)set"
for r :: "('a × 'a)set"
where
"(x,y) ∈ r ⟹ (x,y) ∈ crt2 r" (* contiene a r *)
| "(x,x) ∈ crt2 r" (* reflexiva *)
| "⟦(x,y) ∈ crt2 r; (y,z) ∈ crt2 r⟧ ⟹ (x,z) ∈ crt2 r" (* transitiva *)

text {* Probaremos que r* coincide con (crt2 r) *}

text {*
Lema. La relación (crt2 r) está contenida en r*.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
apply (induction rule: crt2.induct)
(* 1. ⋀x y. (x, y) ∈ r ⟹ (x, y) ∈ r*
2. ⋀x. (x, x) ∈ r*
3. ⋀x y z. ⟦(x, y) ∈ crt2 r; (x, y) ∈ r*;
(y, z) ∈ crt2 r; (y, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply (erule r_contenida_clausura)
(* 1. ⋀x. (x, x) ∈ r*
2. ⋀x y z. ⟦(x, y) ∈ crt2 r; (x, y) ∈ r*;
(y, z) ∈ crt2 r; (y, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply simp
(* ⋀x y z. ⟦(x, y) ∈ crt2 r; (x, y) ∈ r*;
(y, z) ∈ crt2 r; (y, z) ∈ r*⟧
⟹ (x, z) ∈ r* *)
apply (erule crt_trans)
(* ⋀x y z. ⟦(x, y) ∈ crt2 r; (y, z) ∈ crt2 r; (y, z) ∈ r*⟧
⟹ (y, z) ∈ r* *)
apply assumption
(* *)
done

(* La demostración automática es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
by (induction rule: crt2.induct)
(auto simp add: r_contenida_clausura
crt_trans)

(* La demostración declarativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
proof (induction rule: crt2.induct)
fix x y
assume "(x,y) ∈ r"
then show "(x,y) ∈ r*" by (rule r_contenida_clausura) (* blast*)
next
fix x
show "(x,x) ∈ r*" by simp
next
fix x y z
assume H1: "(x,y) ∈ crt2 r" and
H2: "(x,y) ∈ r*" and
H3: "(y,z) ∈ crt2 r" and
H4: "(y,z) ∈ r*"
show "(x,z) ∈ r*" using H2 H4 by (rule crt_trans)
qed

text {*
Lema. La relación r* está contenida en (crt2 r).
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
apply (induction rule: crt.induct)
(* 1. ⋀x. (x, x) ∈ crt2 r
2. ⋀x y z. ⟦(x, y) ∈ r; (y, z) ∈ r*; (y, z) ∈ crt2 r⟧
⟹ (x, z) ∈ crt2 r *)
apply (rule crt2.intros(2))
(* ⋀x y z. ⟦(x, y) ∈ r; (y, z) ∈ r*; (y, z) ∈ crt2 r⟧
⟹ (x, z) ∈ crt2 r *)
apply (drule crt2.intros(1))
(* ⋀x y z. ⟦(y, z) ∈ r*; (y, z) ∈ crt2 r; (x, y) ∈ crt2 r⟧
⟹ (x, z) ∈ crt2 r *)
apply (drule_tac x=x and z=z in crt2.intros(3))
(* 1. ⋀x y z. ⟦(y, z) ∈ r*; (y, z) ∈ crt2 r⟧
⟹ (y, z) ∈ crt2 r
2. ⋀x y z. ⟦(y, z) ∈ r*; (y, z) ∈ crt2 r; (x, z) ∈ crt2 r⟧
⟹ (x, z) ∈ crt2 r *)
apply assumption+
(* *)
done

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
by (induction rule: crt.induct)
(auto intro: crt2.intros)

(* La demostración declarativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
proof (induction rule:crt.induct)
fix x
show "(x,x) ∈ crt2 r" by (rule crt2.intros(2))
next
fix x y z
assume H1: "(x,y) ∈ r" and
H2: "(y,z) ∈ r*" and
H3: "(y,z) ∈ crt2 r"
have "(x,y) ∈ crt2 r" using H1 by (rule crt2.intros(1))
then show "(x,z) ∈ crt2 r" using H3 by (rule crt2.intros(3))
qed

text {* ----------------------------------------------------------------
Ejercicio 1. Demostrar que si (x,y) ∈ r* e (y,z) ∈ r, entonces
(x,z) ∈ r*
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
apply (induction rule: crt.induct)
(* 1. ⋀x. (x, z) ∈ r ⟶ (x, z) ∈ r*
2. ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r ⟶ (y, z) ∈ r*⟧
⟹ (za, z) ∈ r ⟶ (x, z) ∈ r* *)
apply (simp add: r_contenida_clausura)
(* ⋀x y za. ⟦(x, y) ∈ r;
(y, za) ∈ r*;
(za, z) ∈ r ⟶ (y, z) ∈ r*⟧
⟹ (za, z) ∈ r ⟶ (x, z) ∈ r* *)
apply (simp add: crt_paso)
(* *)
done

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
by (induction rule: crt.induct)
(auto simp add: r_contenida_clausura
crt_paso)

(* Demostración declarativa *)
lemma crt_paso2 [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
proof (induction rule: crt.induct)
fix x
show "(x,z) ∈ r ⟶ (x,z) ∈ r*" by (simp add: r_contenida_clausura)
next
fix x y u
assume H1: "(x,y) ∈ r" and
H2: "(y,u) ∈ r*" and
H3: "(u,z) ∈ r ⟶ (y,z) ∈ r*"
show "(u,z) ∈ r ⟶ (x,z) ∈ r*"
proof
assume "(u,z) ∈ r"
with H3 have "(y,z) ∈ r*" ..
with H1 show "(x,z) ∈ r*" by (rule crt_paso)
qed
qed

text {* ----------------------------------------------------------------
Ejercicio 2. Considerar la siguiente definición de la clausura tran-
sitiva de una relación r, y probar que es la menor relación reflexiva
y transitiva que contiene a r.

Nota: Establecer los lemas necesarios.
------------------------------------------------------------------- *}

inductive star' :: "('a ⇒ 'a ⇒ bool) ⇒ 'a ⇒ 'a ⇒ bool" for r where
refl': "star' r x x"
| step': "star' r x y ⟹ r y z ⟹ star' r x z"

(* Demostración de que (star' r) es reflexiva *)
lemma star'Refl: "star' r x x"
by (simp add: refl')

(* Demostración aplicativa de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
apply (rule_tac y=x in step')
(* 1. r x y ⟹ star' r x x
2. r x y ⟹ r x y *)
apply (rule refl')
(* r x y ⟹ r x y *)
apply assumption
(* *)
done

(* Demostración automática de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
by (meson refl' step')

lemma rsubsetStar'_b: "r x y ⟹ star' r x y"
by (simp add:step'[OF refl'[of r x]])

(* Demostración declarativa de r contenida en (star' r) *)
lemma rsubsetStar': "r x y ⟹ star' r x y"
proof -
assume 1:"r x y"
have 2: "star' r x x" by (simp add: refl')
show "star' r x y" using 2 1 by (simp add: step')
qed

text {* A continuación se prueba una vondición suficiente para star' r *}

(* Demostración aplicativa *)
lemma
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
apply (induct rule: star'.induct)
(* 1. ⋀xa. r x xa ⟹ star' r x xa
2. ⋀xa y z. ⟦star' r xa y; r x xa ⟹ star' r x y; r y z; r x xa⟧
⟹ star' r x z *)
apply (simp add: rsubsetStar')
(* ⋀xa y z. ⟦star' r xa y; r x xa ⟹ star' r x y; r y z; r x xa⟧
⟹ star' r x z *)
apply (simp add: step')
(* *)
done

(* Demostración automática *)
lemma star'_subset_star'_l1:
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
by (induct rule: star'.induct)
(auto simp add: rsubsetStar' step')

(* Demostraciones de que (star' r) es transitiva *)

(* Demostración aplicativa *)
lemma "⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
apply (induction rule: star'.induct)
(* 1. ⋀x. star' r x z ⟹ star' r x z
2. ⋀x y za. ⟦star' r x y; star' r y z ⟹ star' r x z; r y za;
star' r za z⟧
⟹ star' r x z *)
apply simp
(* ⋀x y za. ⟦star' r x y; star' r y z ⟹ star' r x z; r y za;
star' r za z⟧
⟹ star' r x z *)
apply (simp add: star'_subset_star'_l1)
(* *)
done

(* Demostración automática *)
lemma star'Trans:
"⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
by (induction rule: star'.induct)
(auto simp add: star'_subset_star'_l1)

text {*
---------------------------------------------------------------------
Ejercicio 3. Considerar la siguiente definición inductiva. Probar que
"star' r x y syss (∃n. iter r n x y)"
------------------------------------------------------------------- *}

inductive iter :: "('a ⇒ 'a ⇒ bool) ⇒ nat ⇒ 'a ⇒ 'a ⇒ bool"
for r where
iterRefl: "iter r 0 x x"
| iterStep: "⟦iter r n x y; r y z⟧ ⟹ iter r (n+1) x z"

(* El esquema de inducción correspondiente es *)
thm iter.induct
(*
⟦iter ?r ?x1.0 ?x2.0 ?x3.0;
⋀x. ?P 0 x x;
⋀n x y z. ⟦iter ?r n x y; ?P n x y; ?r y z⟧ ⟹ ?P (n + 1) x z⟧
⟹ ?P ?x1.0 ?x2.0 ?x3.0
*)

(* Algunos teoremas derivados son *)

thm iterRefl
(* iter ?r 0 ?x ?x *)

thm iterRefl [of r y]
(* iter r 0 y y *)

thm iterStep
(* ⟦iter ?r ?n ?x ?y; ?r ?y ?z⟧ ⟹ iter ?r (?n + 1) ?x ?z *)

thm iterStep [of r x y n z]
(* ⟦iter r x y n; r n z⟧ ⟹ iter r (x + 1) y z *)

thm iterStep [of r x y 0 y]
(* ⟦iter r x y 0; r 0 y⟧ ⟹ iter r (x + 1) y y *)

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar
star' r x y ⟹ (∃n. iter r n x y)
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "star' r x y ⟹ (∃n. iter r n x y)"
apply (induct rule: star'.induct)
(* 1. ⋀x. ∃n. iter r n x x
2. ⋀x y z. ⟦star' r x y; ∃n. iter r n x y; r y z⟧
⟹ ∃n. iter r n x z *)
apply (rule_tac x=0 in exI)
(* 1. ⋀x. iter r 0 x x
2. ⋀x y z. ⟦star' r x y; ∃n. iter r n x y; r y z⟧
⟹ ∃n. iter r n x z *)
apply (rule iterRefl)
(* ⋀x y z. ⟦star' r x y; ∃n. iter r n x y; r y z⟧
⟹ ∃n. iter r n x z *)
apply (erule exE)
(* ⋀x y z n. ⟦star' r x y; r y z; iter r n x y⟧
⟹ ∃n. iter r n x z *)
apply (rule_tac x="n+1" in exI)
(* ⋀x y z n. ⟦star' r x y; r y z; iter r n x y⟧
⟹ iter r (n + 1) x z *)
apply (erule iterStep)
(* ⋀x y z n. ⟦star' r x y; r y z⟧ ⟹ r y z *)
apply assumption
(* *)
done

(* Demostración automática *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
by (induct rule: star'.induct)
(auto intro: iterRefl iterStep)

(* Demostración declarativa *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
proof (induct rule: star'.induct)
fix x
have "iter r 0 x x" by (rule iterRefl)
then show "∃n. iter r n x x" ..
next
fix x y z
assume 1: "star' r x y" and
2: "∃n. iter r n x y" and
3: "r y z"
from 2 obtain m where "iter r m x y" ..
then have "iter r (m+1) x z" using 3 by (rule iterStep)
then show "∃n. iter r n x z" ..
qed

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar
(∃n. iter r n x y) ⟹ star' r x y
------------------------------------------------------------------- *}

(* En la demostración se usará el siguiente lema:
iter r n x y ⟹ star' r x y *)

(* Demostración aplicativa del lema *)
lemma iter_star'_subset: "iter r n x y ⟹ star' r x y"
apply (induct rule: iter.induct)
(* 1. ⋀x. star' r x x
2. ⋀n x y z. ⟦iter r n x y; star' r x y; r y z⟧
⟹ star' r x z *)
apply (rule refl')
(* ⋀n x y z. ⟦iter r n x y; star' r x y; r y z⟧
⟹ star' r x z *)
apply (erule step')
(* ⋀n x y z. ⟦iter r n x y; r y z⟧ ⟹ r y z*)
apply assumption
done

(* Demostración automática del lema *)
lemma "iter r n x y ⟹ star' r x y"
by (induct rule: iter.induct)
(auto simp add: refl' step')

(* Demostración aplicativa *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
apply (erule exE)
(* ⋀n. iter r n x y ⟹ star' r x y *)
apply (erule iter_star'_subset)
(* *)
done

(* Demostración automática *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
by (auto simp add: iter_star'_subset)

(* Demostración declarativa *)
lemma assumes "(∃n. iter r n x y)"
shows "star' r x y"
proof -
have "∃n. iter r n x y" using assms .
then obtain k where "iter r k x y" ..
then show "star' r x y" by (rule iter_star'_subset)
qed

end

</source>

Sol 14

2019-06-26T16:02:01Z

Mjoseh:

<source lang = "isabelle">

theory R14_sol
imports Main

begin

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 1. Hilbert publicó una axiomatización de la geometría que incluía los siguientes
axiomas:
1. Por dos puntos distintos pasa una línea recta.
2. Por dos puntos distintos no pasa más de una línea recta.
3. Toda línea tiene al menos dos puntos.
4. Existen al menos tres puntos no alineados.

Usando la relacion en(p,l) para representar que el punto p está en la línea l, definir el entorno
local Geom en el que se verifiquen los 4 axiomas anteriores.
--------------------------------------------------------------------------------------------------
*}

locale Geom =
fixes en :: "'p ⇒ 'l ⇒ bool"
assumes linea_por_dos_puntos: "a ≠ b ⟹ ∃l. en a l ∧ en b l"
and linea_por_dos_puntos_unica: "⟦a ≠ b; en a l; en b l; en a m; en b m⟧ ⟹ l = m"
and dos_puntos_de_la_linea: "∃a b. a ≠ b ∧ en a l ∧ en b l"
and tres_puntos_no_alineados: "∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧
¬ (∃l. en a l ∧ en b l ∧ en c l)"
begin

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 2. Demostrar que
∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)"
using tres_puntos_no_alineados by auto

(* Demostración detallada *)
lemma tres_puntos_no_alineados_alt:
"∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)"
proof -
obtain a b c where distintos: "a ≠ b ∧ a ≠ c ∧ b ≠ c"
"¬ (∃l. en a l ∧ en b l ∧ en c l)"
using tres_puntos_no_alineados by blast
then have "∀l. en a l ∧ en b l ⟶ ¬ en c l"
by blast
then show ?thesis using distintos by blast
qed

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 3. Demostrar que no todos los puntos pertenecen a la misma línea.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∀l. ∃x. ¬ en x l"
using tres_puntos_no_alineados_alt by auto

(* Demostración detallada sin auto *)
lemma punto_no_en_linea: "∀l. ∃x. ¬ en x l"
proof
fix l
obtain a b c where l3: "¬ (en a l ∧ en b l ∧ en c l)" using tres_puntos_no_alineados by blast
then show "∃x. ¬ en x l" by blast
qed

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 4. Demostrar que por cada punto pasa más de una línea.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∃l m. en x l ∧ en x m ∧ l ≠ m"
by (metis linea_por_dos_puntos tres_puntos_no_alineados_alt)

(* Demostración detallada *)
lemma dos_lineas_por_punto: "∃l m. en x l ∧ en x m ∧ l ≠ m"
proof -
obtain z where "z ≠ x" using dos_puntos_de_la_linea by metis
then obtain l where xl: "en x l" and zl: "en z l" using linea_por_dos_puntos by blast
obtain w where n_wl: "¬ en w l" using punto_no_en_linea by blast
obtain m where wm: "en x m" and zm: "en w m" using linea_por_dos_puntos xl by metis
then have "l ≠ m" using n_wl by blast
then show ?thesis using wm xl by blast
qed

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 5. Demostrar que dos líneas distintas no pueden tener más de un punto común.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma
assumes "l ≠ m"
"en x l"
"en x m"
"en y l"
"en y m"
shows "x = y"
using assms linea_por_dos_puntos_unica by blast

(* Demostración detallada *)
lemma interseccion_lineas_distintas:
assumes "l ≠ m"
"en x l"
"en x m"
"en y l"
"en y m"
shows "x = y"
proof (rule ccontr)
assume "x ≠ y"
then have "l = m" using linea_por_dos_puntos_unica assms(2-5) by simp
then show "False" using assms(1) by simp
qed

end

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 6. Extender el ámbito ("locale") Geom definiendo la relación colineal tal que
(colineal a b c) se verifica si existe una línea recta que pasa por los puntos a, b y c.
--------------------------------------------------------------------------------------------------
*}

definition (in Geom)
colineal :: "'p ⇒ 'p ⇒ 'p ⇒ bool"
where "colineal a b c ≡ ∃l. en a l ∧ en b l ∧ en c l"

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 7. Demostrar que existen tres puntos a, b y c tales que
¬ colineal a b c
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma (in Geom) "∃a b c. ¬ colineal a b c"
using colineal_def tres_puntos_no_alineados by blast

(* Demostración detallada *)
lemma (in Geom) "∃a b c. ¬ colineal a b c"
proof -
have "∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧
¬ (∃l. en a l ∧ en b l ∧ en c l)" by (rule tres_puntos_no_alineados)
then have "∃a b c. ¬ (∃l. en a l ∧ en b l ∧ en c l)" by blast
then show ?thesis by (simp add: colineal_def)
qed

end

</source>

Sol 14

2019-06-26T16:01:50Z

Mjoseh:

Sol 13

2019-06-26T16:00:59Z

Mjoseh:

Sol 11

2019-06-26T15:59:23Z

Mjoseh:

<source lang = "isabelle">

chapter {* R11: Razonamiento sobre programas en Isabelle/HOL *}

theory R11_sol
imports Main
begin

text {* ---------------------------------------------------------------
En toda la relación de ejercicios las demostraciones han de realizarse
de las formas siguientes:
(*) detallada
(*) estructurada
(*) aplicativa
(*) automática
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 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)"

value "sumaPotenciasDeDosMasUno 3" ― ‹= 16›

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

lemma sumaPotenciasDeDosMasUno_d:
"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)"
show "sumaPotenciasDeDosMasUno (Suc n) = 2 ^ (Suc n + 1)"
proof -
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 ?thesis .
qed
qed

lemma sumaPotenciasDeDosMasUno_e:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
oops

lemma sumaPotenciasDeDosMasUno_a:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induct n)
apply simp_all
done

lemma sumaPotenciasDeDosMasUno_auto:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) simp_all

text {* ---------------------------------------------------------------
Ejercicio 3. 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"

value "copia 3 x" ― ‹= [x,x,x]›

text {* ---------------------------------------------------------------
Ejercicio 4. 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 ∧
----------------------------------------------------------------- *}

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

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

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

lemma todos_copia_d: "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

lemma todos_copia_e: "todos (λy. y=x) (copia n x)"
oops

lemma todos_copia_a: "todos (λy. y=x) (copia n x)"
apply (induct n)
apply simp_all
done

lemma todos_copia_auto: "todos (λy. y=x) (copia n x)"
by (induct n) simp_all

text {* ---------------------------------------------------------------
Ejercicio 6. 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"

value "factR 4" ― ‹= 24›

text {* ---------------------------------------------------------------
Ejercicio 7. 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
------------------------------------------------------------------- *}

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"

lemma fact_d: "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 only: mult.assoc)
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

lemma fact_e: "factI' n x = x * factR n"
oops

thm mult_Suc
thm mult.assoc

lemma fact_a: "factI' n x = x * factR n"
apply (induct n arbitrary: x)
apply simp
apply (simp del: mult_Suc)
done

lemma fact_auto: "factI' n x = x * factR n"
by (induct n arbitrary: x) (auto simp del: mult_Suc)

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar que
factI n = factR n
------------------------------------------------------------------- *}

corollary fact_equiv: "factI n = factR n"
by (simp add: fact_a)

text {* ---------------------------------------------------------------
Ejercicio 9. 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"

value "amplia [d,a] t" ― ‹= [d,a,t]›

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

lemma amplia_append_d: "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

lemma amplia_append_e: "amplia xs y = xs @ [y]"
oops

lemma amplia_append_a: "amplia xs y = xs @ [y]"
apply (induct xs)
apply simp_all
done

lemma amplia_append_auto: "amplia xs y = xs @ [y]"
by (induct xs) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 11. 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.
---------------------------------------------------------------------
*}

fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = ((p x) ∨ (algunos p xs))"

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

lemma conjCommuta4: "a ∧ b ∧ c ∧ d ⟷ a ∧ c ∧ b ∧ d"
apply (rule iffI)
apply (rule conjI)
apply (erule conjunct1)
apply (rule conjI)
apply (drule conjunct2)
apply (drule conjunct2)
apply (erule conjunct1)
apply (drule conjunct2)
apply (frule conjunct1)
apply (drule conjunct2)+
apply (rule conjI, assumption+)
apply auto
done

lemma todos_conj_d: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
oops

lemma todos_conj_e: "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)"
thus "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto
qed

thm mult_Suc
thm mult.assoc

lemma todos_conj_a: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
apply (induct xs)
apply simp
apply simp
apply (simp add: conjCommuta4)
done

lemma todos_conj_auto: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

lemma todos_append_d: "todos P (xs @ ys) = (todos P xs ∧ todos P ys)"
proof (induct xs)
show "todos P ([] @ ys) = (todos P [] ∧ todos P ys)" by simp
next
fix a xs
assume HI:"todos P (xs @ ys) = (todos P xs ∧ todos P ys)"
show "todos P ((a # xs) @ ys) = (todos P (a # xs) ∧ todos P ys)"
proof -
have "todos P ((a#xs) @ ys) = ((P a) ∧ todos P (xs@ys))" by simp
also have "... = ((P a) ∧ todos P xs ∧ todos P ys)" using HI by simp
also have "... = (todos P (a#xs) ∧ todos P ys)" by simp
finally show ?thesis .
qed
qed

lemma todos_append_e: "todos P (xs @ ys) = (todos P xs ∧ todos P ys)"
proof (induct xs)
show "todos P ([] @ ys) = (todos P [] ∧ todos P ys)" by simp
next
fix a xs
assume "todos P (xs @ ys) = (todos P xs ∧ todos P ys)"
thus "todos P ((a # xs) @ ys) = (todos P (a # xs) ∧ todos P ys)" by auto
qed

lemma todos_append_a: "todos P (xs @ ys) = (todos P xs ∧ todos P ys)"
apply (induct xs)
apply simp_all
done

lemma todos_append_auto: "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma todos_rev_d: "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"
show "todos P (rev (a # xs)) = todos P (a # xs)"
proof -
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_a)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P [a] ∧ todos P xs)" by auto
also have "... = (P a ∧ todos P xs)" by simp
also have "... = todos P (a#xs)" by simp
finally show ?thesis .
qed
qed

lemma todos_rev_e: "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume "todos P (rev xs) = todos P xs"
thus "todos P (rev (a#xs)) = todos P (a#xs)"
by (auto simp add: todos_append_a)
qed

lemma todos_rev_a: "todos P (rev xs) = todos P xs"
oops

lemma todos_rev_auto: "todos P (rev xs) = todos P xs"
by (induct xs) (auto simp add: todos_append_a)

text {*
---------------------------------------------------------------------
Ejercicio 15. 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

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

lemma algunos_map_d: "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 a xs
assume HI: "algunos P (map f xs) = algunos (P o f) xs"
show "algunos P (map f (a#xs)) = algunos (P o f) (a#xs)"
proof -
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 o f) a) ∨ (algunos (P o f) xs))" using HI by simp
also have "... = algunos (P o f) (a#xs)" by simp
finally show ?thesis .
qed
qed

lemma algunos_map_e: "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 a xs
assume "algunos P (map f xs) = algunos (P o f) xs"
thus "algunos P (map f (a#xs)) = algunos (P o f) (a#xs)" by auto
qed

thm algunos.simps

lemma algunos_map_a: "algunos P (map f xs) = algunos (P o f) xs"
apply (induct xs)
apply simp_all
done

thm conj_commute

lemma algunos_map_auto: "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

lemma algunos_append_d: "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)"
show "algunos P ((a#xs) @ ys) = (algunos P (a#xs) ∨ algunos P ys)"
proof -
have "algunos P ((a#xs) @ ys) = algunos P (a#(xs @ ys))" by simp
also have "... = ((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 ?thesis .
qed
qed

thm Fun.comp_apply

lemma algunos_append_e: "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 "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
thus "algunos P ((a#xs) @ ys) = (algunos P (a#xs) ∨ algunos P ys)"
by auto
qed

lemma algunos_append_a: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
oops

lemma algunos_append_auto: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 18. Demostrar o refutar
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

lemma algunos_rev_d: "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"
show "algunos P (rev (a#xs)) = algunos P (a#xs)"
proof -
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_auto)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P xs ∨ P a)" by simp
also have "... = (P a ∨ algunos P xs)" by (rule disj_commute)
also have "... = algunos P (a#xs)" by simp
finally show ?thesis .
qed
qed

lemma algunos_rev_e: "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume "algunos P (rev xs) = algunos P xs"
thus "algunos P (rev (a#xs)) = algunos P (a#xs)"
by (auto simp add: algunos_append_auto)
qed

lemma algunos_rev_a: "algunos P (rev xs) = algunos P xs"
apply (induct xs)
apply simp
apply (simp add: algunos_append_auto)
apply (simp add: disj_commute)
done

lemma algunos_rev_auto: "algunos P (rev xs) = algunos P xs"
by (induct xs) (auto simp add: algunos_append_auto)

text {*
---------------------------------------------------------------------
Ejercicio 19. 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.
---------------------------------------------------------------------
*}

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)"
apply (induct xs)
apply simp
apply simp
by 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 "algunos (λx. (P x ∨ Q x)) xs = (algunos P xs ∨ algunos Q xs)"
thus "algunos (λx. P x ∨ Q x) (a#xs) = (algunos P(a#xs) ∨ algunos Q (a#xs))"
by auto
qed

text {*
---------------------------------------------------------------------
Ejercicio 20. Demostrar o refutar
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

lemma algunos_no_todos_d: "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)"
show "algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # xs))"
proof -
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 ?thesis .
qed
qed

lemma algunos_no_todos_e: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

lemma algunos_no_todos_a: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

lemma algunos_no_todos_auto: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 21. Definir la función
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
---------------------------------------------------------------------
*}

fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
| "estaEn x (a#xs) = (x=a ∨ estaEn x xs)"

text {*
---------------------------------------------------------------------
Ejercicio 22. Expresar la relación existente entre estaEn y algunos.
Demostrar dicha relación de forma automática y detallada.
---------------------------------------------------------------------
*}

lemma estaEn_algunos_auto:
"estaEn y xs = algunos (λx. y=x) xs"
by (induct xs) simp_all

lemma estaEn_algunos_a:
"estaEn y xs = algunos (λx. y=x) xs"
apply (induct xs)
apply simp
apply simp
done

lemma estaEn_algunos_e:
"estaEn y xs = algunos (λ x. y=x) xs"
proof (induct xs)
show "estaEn y [] = algunos (λ x. y=x) []" by simp
next
fix a xs
assume "estaEn y xs = algunos (λ x. y=x) xs"
thus "estaEn y (a#xs) = algunos (λ x. y=x) (a#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 23. Definir la función
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
---------------------------------------------------------------------
*}

fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (a#xs) = ((¬ estaEn a xs) ∧ sinDuplicados xs)"

text {*
---------------------------------------------------------------------
Ejercicio 24. Definir la función
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.
---------------------------------------------------------------------
*}

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (a#xs) = (if estaEn a xs
then borraDuplicados xs
else (a#borraDuplicados xs))"

text {*
---------------------------------------------------------------------
Ejercicio 25. Demostrar o refutar
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

lemma length_borraDuplicados_d:
"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"
show "length (borraDuplicados (a#xs)) ≤ length (a#xs)"
proof (cases)
assume "estaEn a xs"
hence "length (borraDuplicados (a#xs)) = length (borraDuplicados xs)"
by simp
also have "... ≤ length xs" using HI by simp
also have "... ≤ length (a#xs)" by simp
finally show ?thesis .
next
assume "(¬ estaEn a xs)"
hence "length (borraDuplicados (a#xs)) = length (a#(borraDuplicados xs))"
by simp
also have "... = 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
also have "... = length (a#xs)" by simp
finally show ?thesis .
qed
qed

lemma length_borraDuplicados_e:
"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"
thus "length (borraDuplicados (a#xs)) ≤ length (a#xs)"
proof (cases)
assume "estaEn a xs"
thus "length (borraDuplicados (a#xs)) ≤ length (a#xs)"
using HI by auto
next
assume "(¬ estaEn a xs)"
thus "length (borraDuplicados (a#xs)) ≤ length (a#xs)"
using HI by auto
qed
qed

lemma length_borraDuplicados_a:
"length (borraDuplicados xs) ≤ length xs"
oops

lemma length_borraDuplicados_auto:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 26. Demostrar o refutar
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

lemma estaEn_borraDuplicados_d:
"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 c1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
thus "estaEn a (b#xs)" using c1 HI by auto
next
assume "¬ estaEn b xs"
thus "estaEn a (b#xs)" using c1 HI by auto
qed
next
assume c2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
thus "estaEn a (borraDuplicados (b#xs))" using HI by auto
next
assume "a ≠ b"
thus "estaEn a (borraDuplicados (b#xs))" using `a ≠ b` c2 HI by auto
qed
qed
qed

lemma estaEn_borraDuplicados_e:
"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 c1: "estaEn a (borraDuplicados (b#xs))"
show "estaEn a (b#xs)"
proof (cases)
assume "estaEn b xs"
thus "estaEn a (b#xs)" using c1 HI by auto
next
assume "¬ estaEn b xs"
thus "estaEn a (b#xs)" using c1 HI by auto
qed
next
assume c2: "estaEn a (b#xs)"
show "estaEn a (borraDuplicados (b#xs))"
proof (cases)
assume "a=b"
thus "estaEn a (borraDuplicados (b#xs))" using HI by auto
next
assume "a ≠ b"
thus "estaEn a (borraDuplicados (b#xs))" using `a ≠ b` c2 HI by auto
qed
qed
qed

lemma estaEn_borraDuplicados_a:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

lemma estaEn_borraDuplicados_auto:
"estaEn a (borraDuplicados xs) = estaEn a xs"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 27. Demostrar o refutar
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

lemma sinDuplicados_borraDuplicados_d:
"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"
thus "sinDuplicados (borraDuplicados (a#xs))" using HI by simp
next
assume "¬ estaEn a xs"
hence "¬ (estaEn a xs) ∧ sinDuplicados (borraDuplicados xs)"
using HI by simp
hence "¬ estaEn a (borraDuplicados xs) ∧ sinDuplicados (borraDuplicados xs)"
by (simp add: estaEn_borraDuplicados_auto)
hence "sinDuplicados (a#borraDuplicados xs)" by simp
thus "sinDuplicados (borraDuplicados (a#xs))"
using `¬ estaEn a xs` by simp
qed
qed

lemma sinDuplicados_borraDuplicados_e:
"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"
thus "sinDuplicados (borraDuplicados (a#xs))" using HI by simp
next
assume "¬ estaEn a xs"
thus "sinDuplicados (borraDuplicados (a#xs))"
using `¬ estaEn a xs` HI by (auto simp add: estaEn_borraDuplicados_auto)
qed
qed

lemma sinDuplicados_borraDuplicados_a:
"sinDuplicados (borraDuplicados xs)"
oops

lemma sinDuplicados_borraDuplicados_auto:
"sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados_auto)

text {*
---------------------------------------------------------------------
Ejercicio 28. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
oops

end

</source>

Sol 10

2019-06-26T15:59:04Z

Mjoseh:

<source lang = "isabelle">

chapter {* R10: Programación funcional en Isabelle/HOL *}

theory R10_sol
imports Main
begin

text {* ---------------------------------------------------------------
Ejercicio 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)"

value "sumaPotenciasDeDosMasUno 3" ― ‹= 16›

text {* ---------------------------------------------------------------
Ejercicio 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

------------------------------------------------------------------- *}

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"

value "factI 4" ― ‹= 24›

text {* ---------------------------------------------------------------
Ejercicio 3. 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"

value "amplia [d,a] t" ― ‹= [d,a,t]›

text {* ---------------------------------------------------------------
Ejercicio 4. 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 ∧
----------------------------------------------------------------- *}

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

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

text {*
---------------------------------------------------------------------
Ejercicio 5. 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.
---------------------------------------------------------------------
*}

fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = ((p x) ∨ (algunos p xs))"

text {*
---------------------------------------------------------------------
Ejercicio 6. Definir recursivamente la función
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
---------------------------------------------------------------------
*}

fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
| "estaEn x (a#xs) = (x=a ∨ estaEn x xs)"

text {*
---------------------------------------------------------------------
Ejercicio 7. Definir recursivamemte la función
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
---------------------------------------------------------------------
*}

fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (a#xs) = ((¬ estaEn a xs) ∧ sinDuplicados xs)"

text {*
---------------------------------------------------------------------
Ejercicio 8. Definir la recursivamente la función
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.
---------------------------------------------------------------------
*}

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (a#xs) = (if estaEn a xs
then borraDuplicados xs
else (a#borraDuplicados xs))"

end

</source>

Sol 9

2019-06-26T15:58:47Z

Mjoseh:

<source lang = "isabelle">
chapter {* R9 Programación funcional en Isabelle *}

theory R9_sol
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
------------------------------------------------------------------- *}

fun factorial :: "nat ⇒ nat" where
"factorial 0 = 1"
|" factorial (Suc m) = (Suc m)*(factorial m)"

(* value "factorial (4::nat)"*)

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
------------------------------------------------------------------- *}

fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0"
| "longitud (x#xs) = 1 + longitud xs"

value "longitud [a,b,c]" ― ‹= 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)
------------------------------------------------------------------ *}

fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y,x)"

value "intercambia (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]
------------------------------------------------------------------ *}

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

value "inversa [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]
------------------------------------------------------------------ *}

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

value "repite 3 a" ― ‹= [a,a,a]›

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

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

value "conc [a,d] [b,d,a,c]" ― ‹= [a,d,b,d,a,c]›

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

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

value "coge 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]
------------------------------------------------------------------ *}

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

value "elimina 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
------------------------------------------------------------------ *}

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

(*
value "esVacia []" ― ‹= True›
value "esVacia [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]
------------------------------------------------------------------ *}

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

fun inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs = inversaAcAux xs []"

value "inversaAc [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
------------------------------------------------------------------ *}

fun sum :: "nat list ⇒ nat" where
"sum [] = 0"
| "sum (x#xs) = x + sum xs"

(*
value "sum [3,2,5]" ― ‹= 10›
*)

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

fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []"
| "map f (x#xs) = (f x) # map f xs"

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

end
</source>

Sol 12

2019-06-26T15:58:29Z

Mjoseh:

<source lang = "isabelle">
chapter {* R12: Recorridos de árboles *}

theory R12_sol
imports Main
begin

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

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

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

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

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

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

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

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

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

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))
---------------------------------------------------------------------
*}

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H x) = (H x)"
| "espejo (N x i d) = (N x (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)
---------------------------------------------------------------------
*}

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

lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp
finally show ?thesis by simp
qed
qed

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

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

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 HI1: "?P i"
assume HI2: "?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 "... = postOrden (espejo d) @ postOrden (espejo i) @ [x]" by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ rev [x]" using HI1 HI2 by simp
also have "... = rev ([x] @ preOrden i @ preOrden d)" by simp
finally show ?thesis by simp
qed
qed

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

lemma "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

lemma "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"
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 "... = inOrden (espejo d) @ [x] @ inOrden (espejo i)" by simp
also have "... = rev (inOrden d) @ rev [x] @ rev (inOrden i)" using HI1 HI2 by simp
also have "... = rev (inOrden i @ [x] @ inOrden d)" by simp
finally show ?thesis by simp
qed
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
---------------------------------------------------------------------
*}

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
---------------------------------------------------------------------
*}

fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H a) = a"
| "extremo_izquierda (N f x y) = (extremo_izquierda x)"

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

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
---------------------------------------------------------------------
*}

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"

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

lemma inOrdenNoVacio: "inOrden a ≠ []"
apply (induct a)
apply simp_all
done

theorem ultimoInOrden:
"last (inOrden a) = extremo_derecha a"
apply (induct a)
apply simp
apply (simp add: inOrdenNoVacio)
done

theorem "last (inOrden a) = extremo_derecha a"
by (induct a) (simp_all add: inOrdenNoVacio)

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 HI1: "?P i"
assume HI2: "?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: inOrdenNoVacio)
also have "... = extremo_derecha d" using HI2 by simp
also have "... = extremo_derecha (N x i d)" by simp
finally show ?thesis by simp
qed
qed

thm inOrden.simps(2)

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

theorem "hd (inOrden a) = extremo_izquierda a"
apply (induct a)
apply simp
apply (simp add: inOrdenNoVacio)
done

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 HI1: "?P i"
assume HI2: "?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: inOrdenNoVacio)
also have "... = extremo_izquierda i" using HI1 by simp
also have "... = extremo_izquierda (N x i d)" by simp
finally show ?thesis by simp
qed
qed

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

theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) simp_all

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"
show "?P (N x i d)"
proof -
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 ?thesis by simp
qed
qed

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

theorem "hd (preOrden a) = raiz a"
by (induct a) simp_all

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"
show "?P (N x i d)"
proof -
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 ?thesis by simp
qed
qed

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

theorem "hd (inOrden a) = raiz a"
quickcheck
oops

text {*
Quickcheck found a counterexample:
a = N a1 (H a2) (H a1)

Evaluated terms:
hd (inOrden a) = a2
raiz a = a1
*}

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

lemma "last (postOrden a) = raiz a"
by (induct a) simp_all

lemma "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"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d)) = last ((postOrden i)@(postOrden d)@[x])" by simp
also have "... = last [x]" by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show ?thesis by simp
qed
qed

end

</source>

Sol 12

2019-06-26T15:58:15Z

Mjoseh:

Sol 12

2019-06-26T15:57:44Z

Mjoseh:

Sol 11

2019-06-26T15:56:15Z

Mjoseh:

Sol 10

2019-06-26T15:55:21Z

Mjoseh:

Ejercicios

2019-06-26T15:54:24Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]] y [[Sol 9 | una solución]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]] y [[Sol 10 | una solución]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]] y [[Sol 11 | una solución]]).
* '''Relación 12''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R12.thy Recorridos de árboles en Isabelle/HOL] ([[R12 |Enunciado]], [[Relación 12 |Solución colaborativa]] y [[Sol 12 | una solución]]).
* '''Relación 13''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R13.thy Definiciones inductivas: clausuras] ([[R13 |Enunciado]], [[Relación 13 |Solución colaborativa]] y [[Sol 13 | una solución]]).
* '''Relación 14''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R14.thy Desarrollo de teorías axiomáticas] ([[R14 |Enunciado]], [[Relación 14 |Solución colaborativa]] y [[Sol 14 | una solución]]).

Sol 9

2019-06-26T15:53:13Z

Mjoseh:

Ejercicios

2019-06-26T15:52:42Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]] y [[Sol 9 | una solución]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).
* '''Relación 12''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R12.thy Recorridos de árboles en Isabelle/HOL] ([[R12 |Enunciado]], [[Relación 12 |Solución colaborativa]]).
* '''Relación 13''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R13.thy Definiciones inductivas: clausuras] ([[R13 |Enunciado]], [[Relación 13 |Solución colaborativa]]).
* '''Relación 14''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R14.thy Desarrollo de teorías axiomáticas] ([[R14 |Enunciado]], [[Relación 14 |Solución colaborativa]]).

R14

2019-05-28T06:51:43Z

Mjoseh:

<source lang = "isabelle">
theory R14
imports Main

begin

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 1. Hilbert publicó una axiomatización de la geometría que incluía los siguientes
axiomas:
1. Por dos puntos distintos pasa una línea recta.
2. Por dos puntos distintos no pasa más de una línea recta.
3. Toda línea tiene al menos dos puntos.
4. Existen al menos tres puntos no alineados.

Usando la relacion en(p,l) para representar que el punto p está en la línea l, definir el entorno
local Geom en el que se verifiquen los 4 axiomas anteriores.
--------------------------------------------------------------------------------------------------
*}

locale Geom =
fixes en :: "'p ⇒ 'l ⇒ bool"
assumes linea_por_dos_puntos: "a ≠ b ⟹ ∃l. en a l ∧ en b l"
and linea_por_dos_puntos_unica: "⟦a ≠ b; en a l; en b l; en a m; en b m⟧ ⟹ l = m"
and dos_puntos_de_la_linea: "∃a b. a ≠ b ∧ en a l ∧ en b l"
and tres_puntos_no_alineados: "∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧
¬ (∃l. en a l ∧ en b l ∧ en c l)"
begin

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 2. Demostrar que
∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)"
oops

(* Demostración detallada *)
lemma tres_puntos_no_alineados_alt:
"∃a b c. a ≠ b ∧ a ≠ c ∧ b ≠ c ∧ (∀l. en a l ∧ en b l ⟶ ¬ en c l)"
oops

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 3. Demostrar que no todos los puntos pertenecen a la misma línea.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∀l. ∃x. ¬ en x l"
oops

(* Demostración detallada sin auto *)
lemma punto_no_en_linea: "∀l. ∃x. ¬ en x l"
oops

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 4. Demostrar que por cada punto pasa más de una línea.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma "∃l m. en x l ∧ en x m ∧ l ≠ m"
oops

(* Demostración detallada *)
lemma dos_lineas_por_punto: "∃l m. en x l ∧ en x m ∧ l ≠ m"
oops

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 5. Demostrar que dos líneas distintas no pueden tener más de un punto común.
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma
assumes "l ≠ m"
"en x l"
"en x m"
"en y l"
"en y m"
shows "x = y"
oops

(* Demostración detallada *)
lemma interseccion_lineas_distintas:
assumes "l ≠ m"
"en x l"
"en x m"
"en y l"
"en y m"
shows "x = y"
oops

end

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 6. Extender el ámbito ("locale") Geom definiendo la relación colineal tal que
(colineal a b c) se verifica si existe una línea recta que pasa por los puntos a, b y c.
--------------------------------------------------------------------------------------------------
*}

definition (in Geom)
colineal :: "'p ⇒ 'p ⇒ 'p ⇒ bool"
where "colineal a b c ≡ ∃l. en a l ∧ en b l ∧ en c l"

text {*
--------------------------------------------------------------------------------------------------
Ejercicio 7. Demostrar que existen tres puntos a, b y c tales que
¬ colineal a b c
--------------------------------------------------------------------------------------------------
*}

(* Demostración automática *)
lemma (in Geom) "∃a b c. ¬ colineal a b c"
oops

(* Demostración detallada *)
lemma (in Geom) "∃a b c. ¬ colineal a b c"
oops

end

</source>

R14

2019-05-28T06:51:33Z

Mjoseh:

Ejercicios

2019-05-28T06:50:52Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).
* '''Relación 12''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R12.thy Recorridos de árboles en Isabelle/HOL] ([[R12 |Enunciado]], [[Relación 12 |Solución colaborativa]]).
* '''Relación 13''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R13.thy Definiciones inductivas: clausuras] ([[R13 |Enunciado]], [[Relación 13 |Solución colaborativa]]).
* '''Relación 14''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R14.thy Desarrollo de teorías axiomáticas] ([[R14 |Enunciado]], [[Relación 14 |Solución colaborativa]]).

R13

2019-05-21T06:48:07Z

Mjoseh:

R13

2019-05-21T06:47:55Z

Mjoseh:

R13

2019-05-21T06:46:50Z

Mjoseh:

<source lang = "isabelle">
chapter {* R13: Definiciones inductivas: clausuras *}

theory R13
imports Main
begin

section {* La clausura reflexiva transitiva *}

text {*
· Las definiciones inductivas aceptan parámetros; por tanto, permite
expresar funciones que construyen conjuntos.

· La relaciones binarias son conjuntos de pares; por tanto, se pueden
definir inductivamente.
*}

text {*
· La clausura reflexiva y transitiva de una relación r es la menor
relación reflexiva y transitiva que contiene a r.

· Se representa por r*.

· Se puede definir inductivamente, como conjunto:
· (x,x) ∈ r*
· Si (x,y) ∈ r e (y,z) ∈ r*, entonces (x,z) ∈ r*

· La definición inductiva, como conjunto, se puede expresar en
Isabelle/HOL como sigue:
*}

inductive_set
crt :: "('a × 'a) set ⇒ ('a × 'a) set" ("_*" [1000] 999)
for r :: "('a × 'a) set"
where
crt_refl [iff]: "(x,x) ∈ r*"
| crt_paso: "⟦(x,y) ∈ r; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"

text {*
Notas:
· La sintaxis concreta permite escribir r* en lugar de (crt r).
· La definición consta de dos reglas.
· A la regla reflexiva se le añade el atributo iff para aumentar la
automatización.
· A la regla del paso no se le añade ningún atributo, porque r* ocurre
en la izquierda.
· En el resto de esta sección se demuestra que esta definición
coincide con la menor relación reflexiva y transitiva que contiene a
r.
*}

text {*
Lema. La relación r* es reflexiva.
*}

lemma "(x,x) ∈ r*"
oops

text {*
Lema. La relación r* contiene a r.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

(* La demostración automática es *)
lemma r_contenida_clausura [intro]:
"(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

text {*
Notas:
· La ventaja del lema es que se puede declarar como regla de
introducción, porque r* ocurre sólo en la derecha.
· Con la declaración, algunas demostraciones que usan crt_paso se
hacen de manera automática.
*}

text {*
El esquema de inducción de la clausura reflexiva transitiva es
· crt.induct:
⟦(x1, x2) ∈ r*;
⋀x. P x x;
⋀x y z. ⟦(x,y) ∈ r; (y,z) ∈ r*; P y z⟧ ⟹ P x z⟧
⟹ P x1 x2
*}

text {*
Lema. La relación r* es transitiva.
*}

(* La demostración aplicativa es *)
lemma "⟦(x,y) ∈ r*; (y,z) ∈ r*⟧ ⟹ (x,z) ∈ r*"
oops

lemma "⟦ (x,y) ∈ r*; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"
oops

text {*
Otra formulación del lema, con la variable y a la derecha.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

(* La demostración declarativa es *)
lemma crt_trans [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

text {*
Notas:
· La reformulación anterior es un caso particular de la siguiente
heurística:
"Para probar una fórmula por inducción sobre (x1,...,xn) ∈ R,
poner todas las premisas conteniendo cualquiera de lax xi en la
conclusión usando ⟶".
· El atributo "rule_format" transforma ⟶ en ⟹.
*}

text {*
La relación r* está contenida en cualquier relación reflexiva y
transitiva que contenga a r.

Mediante (crt2 r) se define la menor relación reflexiva y transitiva
que contiene a r.
*}

inductive_set
crt2 :: "('a × 'a)set ⇒ ('a × 'a)set"
for r :: "('a × 'a)set"
where
"(x,y) ∈ r ⟹ (x,y) ∈ crt2 r" (* contiene a r *)
| "(x,x) ∈ crt2 r" (* reflexiva *)
| "⟦(x,y) ∈ crt2 r; (y,z) ∈ crt2 r⟧ ⟹ (x,z) ∈ crt2 r" (* transitiva *)

text {* Probaremos que r* coincide con (crt2 r) *}

text {*
Lema. La relación (crt2 r) está contenida en r*.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

text {*
Lema. La relación r* está contenida en (crt2 r).
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

text {* ----------------------------------------------------------------
Ejercicio 1. Demostrar que si (x,y) ∈ r* e (y,z) ∈ r, entonces
(x,z) ∈ r*
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

(* Demostración declarativa *)
lemma crt_paso2 [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

text {* ----------------------------------------------------------------
Ejercicio 2. Considerar la siguiente definición de la clausura tran-
sitiva de una relación r, y probar que es la menor relación reflexiva
y transitiva que contiene a r.

Nota: Establecer los lemas necesarios.
------------------------------------------------------------------- *}

inductive star' :: "('a ⇒ 'a ⇒ bool) ⇒ 'a ⇒ 'a ⇒ bool" for r where
refl': "star' r x x"
| step': "star' r x y ⟹ r y z ⟹ star' r x z"

(* Demostración de que (star' r) es reflexiva *)
lemma star'Refl: "star' r x x"
oops

(* Demostración aplicativa de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
oops

(* Demostración automática de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
oops

(* Demostración declarativa de r contenida en (star' r) *)
lemma rsubsetStar': "r x y ⟹ star' r x y"
oops

text {* A continuación se prueba una condición suficiente para star' r *}

(* Demostración aplicativa *)
lemma
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
oops

(* Demostración automática *)
lemma star'_subset_star'_l1:
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
oops

(* Demostraciones de que (star' r) es transitiva *)

(* Demostración aplicativa *)
lemma "⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
oops

(* Demostración automática *)
lemma star'Trans:
"⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
oops

text {*
---------------------------------------------------------------------
Ejercicio 3. Considerar la siguiente definición inductiva. Probar que
"star' r x y syss (∃n. iter r n x y)"
------------------------------------------------------------------- *}

inductive iter :: "('a ⇒ 'a ⇒ bool) ⇒ nat ⇒ 'a ⇒ 'a ⇒ bool"
for r where
iterRefl: "iter r 0 x x"
| iterStep: "⟦iter r n x y; r y z⟧ ⟹ iter r (n+1) x z"

(* El esquema de inducción correspondiente es *)
thm iter.induct
(*
⟦iter ?r ?x1.0 ?x2.0 ?x3.0;
⋀x. ?P 0 x x;
⋀n x y z. ⟦iter ?r n x y; ?P n x y; ?r y z⟧ ⟹ ?P (n + 1) x z⟧
⟹ ?P ?x1.0 ?x2.0 ?x3.0
*)

(* Algunos teoremas derivados son *)

thm iterRefl
(* iter ?r 0 ?x ?x *)

thm iterRefl [of r y]
(* iter r 0 y y *)

thm iterStep
(* ⟦iter ?r ?n ?x ?y; ?r ?y ?z⟧ ⟹ iter ?r (?n + 1) ?x ?z *)

thm iterStep [of r x y n z]
(* ⟦iter r x y n; r n z⟧ ⟹ iter r (x + 1) y z *)

thm iterStep [of r x y 0 y]
(* ⟦iter r x y 0; r 0 y⟧ ⟹ iter r (x + 1) y y *)

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar
star' r x y ⟹ (∃n. iter r n x y)
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "star' r x y ⟹ (∃n. iter r n x y)"
oops

(* Demostración automática *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
oops

(* Demostración declarativa *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar
(∃n. iter r n x y) ⟹ star' r x y
------------------------------------------------------------------- *}

(* En la demostración se usará el siguiente lema:
iter r n x y ⟹ star' r x y *)

(* Demostración aplicativa del lema *)
lemma iter_star'_subset: "iter r n x y ⟹ star' r x y"
oops

(* Demostración automática del lema *)
lemma "iter r n x y ⟹ star' r x y"
oops

(* Demostración aplicativa *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
oops

(* Demostración automática *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
oops

(* Demostración declarativa *)
lemma assumes "(∃n. iter r n x y)"
shows "star' r x y"
oops

end
chapter {* R13: Definiciones inductivas: clausuras *}

theory R13
imports Main
begin

section {* La clausura reflexiva transitiva *}

text {*
· Las definiciones inductivas aceptan parámetros; por tanto, permite
expresar funciones que construyen conjuntos.

· La relaciones binarias son conjuntos de pares; por tanto, se pueden
definir inductivamente.
*}

text {*
· La clausura reflexiva y transitiva de una relación r es la menor
relación reflexiva y transitiva que contiene a r.

· Se representa por r*.

· Se puede definir inductivamente, como conjunto:
· (x,x) ∈ r*
· Si (x,y) ∈ r e (y,z) ∈ r*, entonces (x,z) ∈ r*

· La definición inductiva, como conjunto, se puede expresar en
Isabelle/HOL como sigue:
*}

inductive_set
crt :: "('a × 'a) set ⇒ ('a × 'a) set" ("_*" [1000] 999)
for r :: "('a × 'a) set"
where
crt_refl [iff]: "(x,x) ∈ r*"
| crt_paso: "⟦(x,y) ∈ r; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"

text {*
Notas:
· La sintaxis concreta permite escribir r* en lugar de (crt r).
· La definición consta de dos reglas.
· A la regla reflexiva se le añade el atributo iff para aumentar la
automatización.
· A la regla del paso no se le añade ningún atributo, porque r* ocurre
en la izquierda.
· En el resto de esta sección se demuestra que esta definición
coincide con la menor relación reflexiva y transitiva que contiene a
r.
*}

text {*
Lema. La relación r* es reflexiva.
*}

lemma "(x,x) ∈ r*"
oops

text {*
Lema. La relación r* contiene a r.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

(* La demostración automática es *)
lemma r_contenida_clausura [intro]:
"(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ r ⟹ (x,y) ∈ r*"
oops

text {*
Notas:
· La ventaja del lema es que se puede declarar como regla de
introducción, porque r* ocurre sólo en la derecha.
· Con la declaración, algunas demostraciones que usan crt_paso se
hacen de manera automática.
*}

text {*
El esquema de inducción de la clausura reflexiva transitiva es
· crt.induct:
⟦(x1, x2) ∈ r*;
⋀x. P x x;
⋀x y z. ⟦(x,y) ∈ r; (y,z) ∈ r*; P y z⟧ ⟹ P x z⟧
⟹ P x1 x2
*}

text {*
Lema. La relación r* es transitiva.
*}

(* La demostración aplicativa es *)
lemma "⟦(x,y) ∈ r*; (y,z) ∈ r*⟧ ⟹ (x,z) ∈ r*"
oops

lemma "⟦ (x,y) ∈ r*; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"
oops

text {*
Otra formulación del lema, con la variable y a la derecha.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

(* La demostración declarativa es *)
lemma crt_trans [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
oops

text {*
Notas:
· La reformulación anterior es un caso particular de la siguiente
heurística:
"Para probar una fórmula por inducción sobre (x1,...,xn) ∈ R,
poner todas las premisas conteniendo cualquiera de lax xi en la
conclusión usando ⟶".
· El atributo "rule_format" transforma ⟶ en ⟹.
*}

text {*
La relación r* está contenida en cualquier relación reflexiva y
transitiva que contenga a r.

Mediante (crt2 r) se define la menor relación reflexiva y transitiva
que contiene a r.
*}

inductive_set
crt2 :: "('a × 'a)set ⇒ ('a × 'a)set"
for r :: "('a × 'a)set"
where
"(x,y) ∈ r ⟹ (x,y) ∈ crt2 r" (* contiene a r *)
| "(x,x) ∈ crt2 r" (* reflexiva *)
| "⟦(x,y) ∈ crt2 r; (y,z) ∈ crt2 r⟧ ⟹ (x,z) ∈ crt2 r" (* transitiva *)

text {* Probaremos que r* coincide con (crt2 r) *}

text {*
Lema. La relación (crt2 r) está contenida en r*.
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
oops

text {*
Lema. La relación r* está contenida en (crt2 r).
*}

(* La demostración aplicativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

(* La demostración automática es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

(* La demostración declarativa es *)
lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
oops

text {* ----------------------------------------------------------------
Ejercicio 1. Demostrar que si (x,y) ∈ r* e (y,z) ∈ r, entonces
(x,z) ∈ r*
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

(* Demostración aplicativa *)
lemma "(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

(* Demostración declarativa *)
lemma crt_paso2 [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) ∈ r*"
oops

text {* ----------------------------------------------------------------
Ejercicio 2. Considerar la siguiente definición de la clausura tran-
sitiva de una relación r, y probar que es la menor relación reflexiva
y transitiva que contiene a r.

Nota: Establecer los lemas necesarios.
------------------------------------------------------------------- *}

inductive star' :: "('a ⇒ 'a ⇒ bool) ⇒ 'a ⇒ 'a ⇒ bool" for r where
refl': "star' r x x"
| step': "star' r x y ⟹ r y z ⟹ star' r x z"

(* Demostración de que (star' r) es reflexiva *)
lemma star'Refl: "star' r x x"
oops

(* Demostración aplicativa de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
oops

(* Demostración automática de r contenida en (star' r) *)
lemma "r x y ⟹ star' r x y"
oops

(* Demostración declarativa de r contenida en (star' r) *)
lemma rsubsetStar': "r x y ⟹ star' r x y"
oops

text {* A continuación se prueba una condición suficiente para star' r *}

(* Demostración aplicativa *)
lemma
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
oops

(* Demostración automática *)
lemma star'_subset_star'_l1:
"⟦star' r y z; r x y⟧ ⟹ star' r x z"
oops

(* Demostraciones de que (star' r) es transitiva *)

(* Demostración aplicativa *)
lemma "⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
oops

(* Demostración automática *)
lemma star'Trans:
"⟦star' r x y; star' r y z⟧ ⟹ star' r x z"
oops

text {*
---------------------------------------------------------------------
Ejercicio 3. Considerar la siguiente definición inductiva. Probar que
"star' r x y syss (∃n. iter r n x y)"
------------------------------------------------------------------- *}

inductive iter :: "('a ⇒ 'a ⇒ bool) ⇒ nat ⇒ 'a ⇒ 'a ⇒ bool"
for r where
iterRefl: "iter r 0 x x"
| iterStep: "⟦iter r n x y; r y z⟧ ⟹ iter r (n+1) x z"

(* El esquema de inducción correspondiente es *)
thm iter.induct
(*
⟦iter ?r ?x1.0 ?x2.0 ?x3.0;
⋀x. ?P 0 x x;
⋀n x y z. ⟦iter ?r n x y; ?P n x y; ?r y z⟧ ⟹ ?P (n + 1) x z⟧
⟹ ?P ?x1.0 ?x2.0 ?x3.0
*)

(* Algunos teoremas derivados son *)

thm iterRefl
(* iter ?r 0 ?x ?x *)

thm iterRefl [of r y]
(* iter r 0 y y *)

thm iterStep
(* ⟦iter ?r ?n ?x ?y; ?r ?y ?z⟧ ⟹ iter ?r (?n + 1) ?x ?z *)

thm iterStep [of r x y n z]
(* ⟦iter r x y n; r n z⟧ ⟹ iter r (x + 1) y z *)

thm iterStep [of r x y 0 y]
(* ⟦iter r x y 0; r 0 y⟧ ⟹ iter r (x + 1) y y *)

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar
star' r x y ⟹ (∃n. iter r n x y)
------------------------------------------------------------------- *}

(* Demostración aplicativa *)
lemma "star' r x y ⟹ (∃n. iter r n x y)"
oops

(* Demostración automática *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
oops

(* Demostración declarativa *)
lemma [rule_format]: "star' r x y ⟹ (∃n. iter r n x y)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar
(∃n. iter r n x y) ⟹ star' r x y
------------------------------------------------------------------- *}

(* En la demostración se usará el siguiente lema:
iter r n x y ⟹ star' r x y *)

(* Demostración aplicativa del lema *)
lemma iter_star'_subset: "iter r n x y ⟹ star' r x y"
oops

(* Demostración automática del lema *)
lemma "iter r n x y ⟹ star' r x y"
oops

(* Demostración aplicativa *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
oops

(* Demostración automática *)
lemma "(∃n. iter r n x y) ⟹ star' r x y"
oops

(* Demostración declarativa *)
lemma assumes "(∃n. iter r n x y)"
shows "star' r x y"
oops

end
</source>

Ejercicios

2019-05-21T06:45:42Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).
* '''Relación 12''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R12.thy Recorridos de árboles en Isabelle/HOL] ([[R12 |Enunciado]], [[Relación 12 |Solución colaborativa]]).
* '''Relación 13''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R13.thy Definiciones inductivas: clausuras] ([[R13 |Enunciado]], [[Relación 13 |Solución colaborativa]]).

R12

2019-05-16T11:17:45Z

Mjoseh:

<source lang = "isabelle">
chapter {* R12: Recorridos de árboles *}

theory R12
imports Main
begin

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

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

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden a = undefined"

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

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

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden a = undefined"

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

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden a = undefined"

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

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))
---------------------------------------------------------------------
*}

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo a = undefined"

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)
---------------------------------------------------------------------
*}

lemma "preOrden (espejo a) = rev (postOrden a)"
oops

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

lemma "postOrden (espejo a) = rev (preOrden a)"
oops

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

theorem "inOrden (espejo a) = rev (inOrden a)"
oops

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
---------------------------------------------------------------------
*}

fun raiz :: "'a arbol ⇒ 'a" where
"raiz a = undefined"

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
---------------------------------------------------------------------
*}

fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda a = undefined"

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

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
---------------------------------------------------------------------
*}

fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha a = undefined"

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

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

theorem "last (inOrden a) = extremo_derecha a"
oops

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

theorem "hd (inOrden a) = extremo_izquierda a"
oops

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

theorem "hd (preOrden a) = last (postOrden a)"
oops

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

theorem "hd (preOrden a) = raiz a"
oops

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

theorem "hd (inOrden a) = raiz a"
oops

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

theorem "last (postOrden a) = raiz a"
oops

end

</source>

R12

2019-05-16T11:17:31Z

Mjoseh:

Ejercicios

2019-05-16T11:16:29Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).
* '''Relación 12''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R12.thy Recorridos de árboles en Isabelle/HOL] ([[R12 |Enunciado]], [[Relación 12 |Solución colaborativa]]).

R11

2019-04-30T09:59:40Z

Mjoseh:

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

theory R11
imports Main
begin

text {* ---------------------------------------------------------------
En toda la relación de ejercicios las demostraciones han de realizarse
de las formas siguientes:
(*) detallada
(*) estructurada
(*) aplicativa
(*) automática
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 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)"

value "sumaPotenciasDeDosMasUno 3" ― ‹= 16›

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

lemma sumaPotenciasDeDosMasUno_d:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
oops

lemma sumaPotenciasDeDosMasUno_e:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
oops

lemma sumaPotenciasDeDosMasUno_a:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
oops

lemma sumaPotenciasDeDosMasUno_auto:
"sumaPotenciasDeDosMasUno n = 2^(n+1)"
oops

text {* ---------------------------------------------------------------
Ejercicio 3. 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"

value "copia 3 x" ― ‹= [x,x,x]›

text {* ---------------------------------------------------------------
Ejercicio 4. 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 ∧
----------------------------------------------------------------- *}

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

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

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

lemma todos_copia_d: "todos (λy. y=x) (copia n x)"
oops

lemma todos_copia_e: "todos (λy. y=x) (copia n x)"
oops

lemma todos_copia_a: "todos (λy. y=x) (copia n x)"
oops

lemma todos_copia_auto: "todos (λy. y=x) (copia n x)"
oops

text {* ---------------------------------------------------------------
Ejercicio 6. 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"

value "factR 4" ― ‹= 24›

text {* ---------------------------------------------------------------
Ejercicio 7. 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
------------------------------------------------------------------- *}

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"

lemma fact_d: "factI' n x = x * factR n"
oops

lemma fact_e: "factI' n x = x * factR n"
oops

lemma fact_a: "factI' n x = x * factR n"
oops

lemma fact_auto: "factI' n x = x * factR n"
oops

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar que
factI n = factR n
------------------------------------------------------------------- *}

corollary fact_equiv: "factI n = factR n"
oops

text {* ---------------------------------------------------------------
Ejercicio 9. 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"

value "amplia [d,a] t" ― ‹= [d,a,t]›

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

lemma amplia_append_d: "amplia xs y = xs @ [y]"
oops

lemma amplia_append_e: "amplia xs y = xs @ [y]"
oops

lemma amplia_append_a: "amplia xs y = xs @ [y]"
oops

lemma amplia_append_auto: "amplia xs y = xs @ [y]"
oops

text {*
---------------------------------------------------------------------
Ejercicio 11. 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.
---------------------------------------------------------------------
*}

fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = ((p x) ∨ (algunos p xs))"

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar o refutar
todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)
---------------------------------------------------------------------
*}

lemma todos_conj_d: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
oops

lemma todos_conj_e: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
oops

lemma todos_conj_a: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
oops

lemma todos_conj_auto: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

lemma todos_append_d: "todos P (x @ y) = (todos P x ∧ todos P y)"
oops

lemma todos_append_e: "todos P (x @ y) = (todos P x ∧ todos P y)"
oops

lemma todos_append_a: "todos P (x @ y) = (todos P x ∧ todos P y)"
oops

lemma todos_append_auto: "todos P (x @ y) = (todos P x ∧ todos P y)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

lemma todos_rev_d: "todos P (rev xs) = todos P xs"
oops

lemma todos_rev_e: "todos P (rev xs) = todos P xs"
oops

lemma todos_rev_a: "todos P (rev xs) = todos P xs"
oops

lemma todos_rev_auto: "todos P (rev xs) = todos P xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 15. 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

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

lemma algunos_map_d: "algunos P (map f xs) = algunos (P o f) xs"
oops

lemma algunos_map_e: "algunos P (map f xs) = algunos (P o f) xs"
oops

lemma algunos_map_a: "algunos P (map f xs) = algunos (P o f) xs"
oops

lemma algunos_map_auto: "algunos P (map f xs) = algunos (P o f) xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

lemma algunos_append_d: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
oops

lemma algunos_append_e: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
oops

lemma algunos_append_a: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
oops

lemma algunos_append_auto: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 18. Demostrar o refutar
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

lemma algunos_rev_d: "algunos P (rev xs) = algunos P xs"
oops

lemma algunos_rev_e: "algunos P (rev xs) = algunos P xs"
oops

lemma algunos_rev_a: "algunos P (rev xs) = algunos P xs"
oops

lemma algunos_rev_auto: "algunos P (rev xs) = algunos P xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 19. 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.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 20. Demostrar o refutar
algunos P xs = (¬ todos (λx. (¬ P x)) xs)
---------------------------------------------------------------------
*}

lemma algunos_no_todos_d: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

lemma algunos_no_todos_e: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

lemma algunos_no_todos_a: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

lemma algunos_no_todos_auto: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 21. Definir la función
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
---------------------------------------------------------------------
*}

fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
| "estaEn x (a#xs) = (x=a ∨ estaEn x xs)"

text {*
---------------------------------------------------------------------
Ejercicio 22. Expresar la relación existente entre estaEn y algunos.
Demostrar dicha relación de forma automática y detallada.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 23. Definir la función
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
---------------------------------------------------------------------
*}

fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (a#xs) = ((¬ estaEn a xs) ∧ sinDuplicados xs)"

text {*
---------------------------------------------------------------------
Ejercicio 24. Definir la función
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.
---------------------------------------------------------------------
*}

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (a#xs) = (if estaEn a xs
then borraDuplicados xs
else (a#borraDuplicados xs))"

text {*
---------------------------------------------------------------------
Ejercicio 25. Demostrar o refutar
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

lemma length_borraDuplicados_d:
"length (borraDuplicados xs) ≤ length xs"
oops

lemma length_borraDuplicados_e:
"length (borraDuplicados xs) ≤ length xs"
oops

lemma length_borraDuplicados_a:
"length (borraDuplicados xs) ≤ length xs"
oops

lemma length_borraDuplicados_auto:
"length (borraDuplicados xs) ≤ length xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 26. Demostrar o refutar
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

lemma estaEn_borraDuplicados_d:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

lemma estaEn_borraDuplicados_e:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

lemma estaEn_borraDuplicados_a:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

lemma estaEn_borraDuplicados_auto:
"estaEn a (borraDuplicados xs) = estaEn a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 27. Demostrar o refutar
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

lemma sinDuplicados_borraDuplicados_d:
"sinDuplicados (borraDuplicados xs)"
oops

lemma sinDuplicados_borraDuplicados_e:
"sinDuplicados (borraDuplicados xs)"
oops

lemma sinDuplicados_borraDuplicados_a:
"sinDuplicados (borraDuplicados xs)"
oops

lemma sinDuplicados_borraDuplicados_auto:
"sinDuplicados (borraDuplicados xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 28. Demostrar o refutar:
borraDuplicados (rev xs) = rev (borraDuplicados xs)
---------------------------------------------------------------------
*}

lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
oops

end

</source>

R11

2019-04-30T09:59:20Z

Mjoseh:

Ejercicios

2019-04-30T09:58:07Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).

Ejercicios

2019-04-30T09:57:48Z

Mjoseh:

En esta página se encuentran los ejercicios para resolver de manera colaborativa que complementan al [https://www.cs.us.es/~jalonso/cursos/lmf-18/ejercicios/ejercicios-LMF-2018-19.pdf libro de ejercicios].
* '''Relación 1''': Sintaxis y semántica de la lógica proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]] y [[Relación 2 |Solución colaborativa]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]] y [[Relación 3 |Solución colaborativa]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]], [[Relación 4 |Solución colaborativa]] y [[Sol 4 | una solución]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]] y [[Relación 5 |Solución colaborativa]]).
* '''Relación 6''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R6.thy Deducción natural en lógica de primer orden con Isabelle] ([[R6 |Enunciado]], [[Relación |Solución colaborativa]] y [[Sol 6 | una solución]]).
* '''Relación 7''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R7.thy Deducción natural en lógica proposicional con Isabelle basada en tácticas] ([[R7 |Enunciado]], [[Relación 7 |Solución colaborativa]] y [[Sol 7 | una solución]]).
* '''Relación 7b''': Deducción natural en lógica de primer orden con Isabelle basada en tácticas. ([[Sol 7b | una solución]]).
* '''Relación 8''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R8.thy Argumentación en lógica de primer orden con Isabelle.] ([[R8 |Enunciado]], [[Relación 8 |Solución colaborativa]] y [[Sol 8 | una solución]]).
* '''Relación 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]], [[Relación 9 |Solución colaborativa]]).
* '''Relación 10''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R10.thy Programación funcional en Isabelle (2)] ([[R10 |Enunciado]], [[Relación 10 |Solución colaborativa]]).
* '''Relación 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]], [[Relación 11 |Solución colaborativa]]).

R10

2019-04-25T10:50:39Z

Mjoseh:

<source lang = "isabelle">
chapter {* R10: Programación funcional en Isabelle/HOL *}

theory R10
imports Main
begin

text {* ---------------------------------------------------------------
Ejercicio 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 n = undefined"

(* value "sumaPotenciasDeDosMasUno 3" ― ‹= 16› *)

text {* ---------------------------------------------------------------
Ejercicio 2. Se considera la siguiente definición 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

------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' n x = undefined"

fun factI :: "nat ⇒ nat" where
"factI n = undefined"

(* value "factI 4" ― ‹= 24› *)

text {* ---------------------------------------------------------------
Ejercicio 3. 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 xs = undefined"

(* value "amplia [d,a] t" ― ‹= [d,a,t]› *)

text {* ---------------------------------------------------------------
Ejercicio 4. 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 ∧
----------------------------------------------------------------- *}

fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p xs = undefined"

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

text {*
---------------------------------------------------------------------
Ejercicio 5. 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.
---------------------------------------------------------------------
*}

fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p xs = undefined"

text {*
---------------------------------------------------------------------
Ejercicio 6. Definir recursivamente la función
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
---------------------------------------------------------------------
*}

fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x xs = undefined"

text {*
---------------------------------------------------------------------
Ejercicio 7. Definir recursivamemte la función
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
---------------------------------------------------------------------
*}

fun sinDuplicados :: "'a list ⇒ bool" where
"sinDuplicados xs = undefined"

text {*
---------------------------------------------------------------------
Ejercicio 8. Definir la recursivamente la función
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.
---------------------------------------------------------------------
*}

fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados xs = undefined"

end

</source>

R10

2019-04-25T10:50:26Z

Mjoseh:

Ejercicios

2019-04-25T10:47:32Z

Mjoseh:

R9

2019-04-23T11:48:38Z

Mjoseh:

<source lang = "isabelle">
chapter {* R9 Programación funcional en Isabelle *}

theory R9
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
------------------------------------------------------------------- *}

fun factorial :: "nat ⇒ nat" where
"factorial n = undefined"

(* value "factorial (4::nat)"*)

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
------------------------------------------------------------------- *}

fun longitud :: "'a list ⇒ nat" where
"longitud xs = undefined"

value "longitud [a,b,c]" ― ‹= 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)
------------------------------------------------------------------ *}

fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = undefined"

value "intercambia (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]
------------------------------------------------------------------ *}

fun inversa :: "'a list ⇒ 'a list" where
"inversa xs = undefined"

value "inversa [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]
------------------------------------------------------------------ *}

fun repite :: "nat ⇒ 'a ⇒ 'a list" where
"repite n x = undefined"

value "repite 3 a" ― ‹= [a,a,a]›

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

fun conc :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc xs ys = undefined"

value "conc [a,d] [b,d,a,c]" ― ‹= [a,d,b,d,a,c]›

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

fun coge :: "nat ⇒ 'a list ⇒ 'a list" where
"coge n xs = undefined"

value "coge 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]
------------------------------------------------------------------ *}

fun elimina :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina n xs = undefined"

value "elimina 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
------------------------------------------------------------------ *}

fun esVacia :: "'a list ⇒ bool" where
"esVacia xs = undefined"

(*
value "esVacia []" ― ‹= True›
value "esVacia [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]
------------------------------------------------------------------ *}

fun inversaAcAux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux xs ys = undefined"

fun inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs = undefined"

value "inversaAc [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
------------------------------------------------------------------ *}

fun sum :: "nat list ⇒ nat" where
"sum xs = undefined"

(*
value "sum [3,2,5]" ― ‹= 10›
*)

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

fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f xs = undefined"

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

end

</source>

R9

2019-04-23T11:48:26Z

Mjoseh:

Ejercicios

2019-04-23T11:47:28Z

Mjoseh:

Sol 7

2019-04-09T10:53:11Z

Mjoseh:

<source lang = "isabelle">
theory R7_sol
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es escribir demostraciones usando sólo
las reglas básicas de deducción natural de la lógica proposicional y
los métodos rule, erule, frule, drule y assumption.

Las reglas básicas de la deducción natural son las siguientes:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· conjE: ⟦P ∧ Q; ⟦P; Q⟧ ⟹ R⟧ ⟹ R
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· impE: ⟦P ⟶ Q; P; Q ⟹ R⟧ ⟹ R
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· iffE: ⟦P = Q; ⟦P ⟶ Q; Q ⟶ P⟧ ⟹ R⟧ ⟹ R
· notnotD: ¬¬ P ⟹ P
· not_not: P = ¬¬P
· ccontr: (¬P ⟹ False) ⟹ P
· excluded_midle: ¬P ∨ P
· classical: (¬ P ⟹ P) ⟹ P
· contrapos_nn ⟦¬Q; P ⟹ Q⟧ ⟹ ¬P
---------------------------------------------------------------------
*}

section {* Implicaciones *}

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
p ⟶ q, p ⊢ q
------------------------------------------------------------------ *}

lemma ej1: "⟦p ⟶ q; p⟧ ⟹ q"
apply (erule mp)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
p ⟶ q, q ⟶ r, p ⊢ r
------------------------------------------------------------------ *}

lemma ej2: "⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r"
apply (erule mp)+
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r
------------------------------------------------------------------ *}

lemma ej3a: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (erule impE)
apply assumption
apply (erule impE)
apply assumption
apply (erule impE)
apply assumption+
done

lemma ej3b: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (erule impE, assumption+)+
done

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
p ⟶ q, q ⟶ r ⊢ p ⟶ r
------------------------------------------------------------------ *}

-- "La demostración detallada es"
lemma ej4: "⟦p ⟶ q; q ⟶ r⟧ ⟹ p ⟶ r"
apply (rule impI)
apply (erule mp)
apply (erule mp)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej5: "p ⟶ (q ⟶ r) ⟹ q ⟶ (p ⟶ r)"
apply (rule impI)
apply (rule impI)
apply (erule impE, assumption)
apply (erule impE, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej6: "p ⟶ (q ⟶ r) ⟹ (p ⟶ q) ⟶ (p ⟶ r)"
apply (rule impI)
apply (rule impI)
apply (erule impE, assumption)
apply (erule impE, assumption)
apply (erule impE, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
p ⊢ q ⟶ p
------------------------------------------------------------------ *}

lemma ej7: "p ⟹ q ⟶ p"
apply (rule impI)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
⊢ p ⟶ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ej8: "p ⟶ (q ⟶ p)"
apply (rule impI)
apply (rule impI)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 9. Demostrar
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej9: "p ⟶ q ⟹ (q ⟶ r) ⟶ (p ⟶ r)"
apply (rule impI)
apply (rule impI)
apply (erule impE, assumption)
apply (erule impE, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))
------------------------------------------------------------------ *}

lemma ej10: "p ⟶ (q ⟶ (r ⟶ s)) ⟹ r ⟶ (q ⟶ (p ⟶ s))"
apply (rule impI)+
apply (erule impE, assumption+)+
done

text {* ---------------------------------------------------------------
Ejercicio 11. Demostrar
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))
------------------------------------------------------------------ *}

lemma ej11: "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
apply (rule impI)+
apply (erule impE, assumption+)+
done

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej12: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+
apply (rule_tac P="p ⟶ q" in mp)
apply assumption
apply (rule impI)
apply assumption
done

section {* Conjunciones *}

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
p, q ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ej13: "⟦p; q⟧ ⟹ p ∧ q"
apply (rule conjI)
apply assumption
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
p ∧ q ⊢ p
------------------------------------------------------------------ *}

lemma ej14: "p ∧ q ⟹ p"
apply (erule conjunct1)
done

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
p ∧ q ⊢ q
------------------------------------------------------------------ *}

lemma ej15: "p ∧ q ⟹ q"
apply (erule conjunct2)
done

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r
------------------------------------------------------------------ *}

lemma ej16: "p ∧ (q ∧ r) ⟹ (p ∧ q) ∧ r"
apply (rule conjI)
apply (rule conjI)
apply (erule conjunct1)
apply (drule conjunct2)
apply (erule conjunct1)
apply (drule conjunct2)
apply (erule conjunct2)
done

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)
------------------------------------------------------------------ *}

lemma ej17: "(p ∧ q) ∧ r ⟹ p ∧ (q ∧ r)"
apply (rule conjI)
apply (drule conjunct1)
apply (erule conjunct1)
apply (rule conjI)
apply (drule conjunct1)
apply (erule conjunct2)
apply (erule conjunct2)
done

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
p ∧ q ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej18: "p ∧ q ⟹ p ⟶ q"
apply (rule impI)
apply (erule conjunct2)
done

text {* ---------------------------------------------------------------
Ejercicio 19. Demostrar
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r
------------------------------------------------------------------ *}

lemma ej19: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
apply (rule impI)
apply (rule conjI)
apply (drule conjunct1)
apply (erule impE)
apply assumption
apply assumption
apply (drule conjunct2)
apply (erule impE)
apply assumption
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 20. Demostrar
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej20: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI)
apply (rule impI)
apply (erule impE)
apply assumption
apply (erule conjunct1)
apply (rule impI)
apply (erule impE)
apply assumption
apply (erule conjunct2)
done

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ej21_1: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
apply (rule impI)
apply (erule conjE)
apply (erule impE)
apply assumption
apply (erule impE)
apply assumption
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej22: "p ∧ q ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)
apply (rule impI)
apply (erule impE)
apply (rule conjI)
apply assumption+
done

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ej23: "(p ⟶ q) ⟶ r ⟹ p ∧ q ⟶ r"
apply (rule impI)
apply (erule impE)
apply (rule impI)
apply (erule conjunct2)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 24. Demostrar
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r
------------------------------------------------------------------ *}

lemma ej24: "p ∧ (q ⟶ r) ⟹ (p ⟶ q) ⟶ r"
apply (rule impI)
apply (erule conjE)
apply (erule impE)
apply assumption
apply (erule impE)
apply assumption+
done

section {* Disyunciones *}

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
p ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej25: "p ⟹ p ∨ q"
apply (erule disjI1)
done

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
q ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej26: "q ⟹ p ∨ q"
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar
p ∨ q ⊢ q ∨ p
------------------------------------------------------------------ *}

lemma ej27: "p ∨ q ⟹ q ∨ p"
apply (erule disjE)
apply (erule disjI2)
apply (erule disjI1)
done

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
------------------------------------------------------------------ *}

lemma ej28: "q ⟶ r ⟹ p ∨ q ⟶ p ∨ r"
apply (rule impI)
apply (erule disjE)
apply (erule disjI1)
apply (erule impE)
apply assumption
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 29. Demostrar
p ∨ p ⊢ p
------------------------------------------------------------------ *}

lemma ej29: "p ∨ p ⟹ p"
apply (erule disjE)
apply assumption+
done

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar
p ⊢ p ∨ p
------------------------------------------------------------------ *}

lemma ej30: "p ⟹ p ∨ p"
apply (erule disjI1)
done

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r
------------------------------------------------------------------ *}

lemma ej31: "p ∨ (q ∨ r) ⟹ (p ∨ q) ∨ r"
apply (erule disjE)
apply (rule disjI1)
apply (erule disjI1)
apply (erule disjE)
apply (rule disjI1)
apply (erule disjI2)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)
------------------------------------------------------------------ *}

lemma ej32: "(p ∨ q) ∨ r ⟹ p ∨ (q ∨ r)"
apply (erule disjE)
apply (erule disjE)
apply (erule disjI1)
apply (rule disjI2)
apply (erule disjI1)
apply (rule disjI2)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 33. Demostrar
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)
------------------------------------------------------------------ *}

lemma ej33: "p ∧ (q ∨ r) ⟹ (p ∧ q) ∨ (p ∧ r)"
apply (erule conjE)
apply (erule disjE)
apply (rule disjI1)
apply (rule conjI)
apply assumption
apply assumption
apply (rule disjI2)
apply (rule conjI)
apply assumption
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 34. Demostrar
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)
------------------------------------------------------------------ *}

lemma ej34: "(p ∧ q) ∨ (p ∧ r) ⟹ p ∧ (q ∨ r)"
apply (rule conjI)
apply (erule disjE)
apply (erule conjunct1)
apply (erule conjunct1)
apply (erule disjE)
apply (erule conjE)
apply (rule disjI1)
apply assumption
apply (erule conjE)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 35. Demostrar
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)
------------------------------------------------------------------ *}

lemma ej35: "p ∨ (q ∧ r) ⟹ (p ∨ q) ∧ (p ∨ r)"
apply (erule disjE)
apply (rule conjI)
apply (erule disjI1)
apply (erule disjI1)
apply (erule conjE)
apply (rule conjI)
apply (erule disjI2)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)
------------------------------------------------------------------ *}

lemma ej36: "(p ∨ q) ∧ (p ∨ r) ⟹ p ∨ (q ∧ r)"
apply (erule conjE)
apply (erule disjE)
apply (erule disjI1)
apply (erule disjE)
apply (erule disjI1)
apply (rule disjI2)
apply (rule conjI)
apply assumption+
done

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r
------------------------------------------------------------------ *}

lemma ej37: "(p ⟶ r) ∧ (q ⟶ r) ⟹ p ∨ q ⟶ r"
apply (rule impI)
apply (erule conjE)
apply (erule disjE)
apply (erule impE, assumption+)+
done

text {* ---------------------------------------------------------------
Ejercicio 38. Demostrar
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej38: "p ∨ q ⟶ r ⟹ (p ⟶ r) ∧ (q ⟶ r)"
apply (rule conjI)
apply (rule impI)
apply (erule impE)
apply (erule disjI1)
apply assumption
apply (rule impI)
apply (erule impE)
apply (erule disjI2)
apply assumption
done

section {* Negación *}

text {* ---------------------------------------------------------------
Ejercicio 39. Demostrar
p ⊢ ¬¬p
------------------------------------------------------------------ *}

lemma ej39: "p ⟹ ¬¬p"
apply (rule notI)
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej40: "¬p ⟹ p ⟶ q"
apply (rule impI)
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 41. Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
------------------------------------------------------------------ *}

lemma ej41: "p ⟶ q ⟹ ¬q ⟶ ¬p"
apply (rule impI)
apply (rule notI)
apply (erule impE)
apply assumption
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p ∨ q, ¬q ⊢ p
------------------------------------------------------------------ *}

lemma ej42: "⟦p ∨ q; ¬q⟧ ⟹ p"
apply (erule disjE)
apply assumption
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 43. Demostrar
p ∨ q, ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ej43: "⟦p ∨ q; ¬p⟧ ⟹ q"
apply (erule disjE)
apply (erule notE)
apply assumption
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 44. Demostrar
p ∨ q ⊢ ¬(¬p ∧ ¬q)
------------------------------------------------------------------ *}

lemma ej44: "p ∨ q ⟹ ¬(¬p ∧ ¬q)"
apply (rule notI)
apply (erule conjE)
apply (erule disjE)
apply (erule notE, assumption)+
done

text {* ---------------------------------------------------------------
Ejercicio 45. Demostrar
p ∧ q ⊢ ¬(¬p ∨ ¬q)
------------------------------------------------------------------ *}

lemma ej45: "p ∧ q ⟹ ¬(¬p ∨ ¬q)"
apply (rule notI)
apply (erule conjE)
apply (erule disjE)
apply (erule notE, assumption)+
done

text {* ---------------------------------------------------------------
Ejercicio 46. Demostrar
¬(p ∨ q) ⊢ ¬p ∧ ¬q
------------------------------------------------------------------ *}

lemma ej46: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
apply (rule conjI)
apply (rule notI)
apply (erule notE)
apply (erule disjI1)
apply (rule notI)
apply (erule notE)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 47. Demostrar
¬p ∧ ¬q ⊢ ¬(p ∨ q)
------------------------------------------------------------------ *}

lemma ej47: "¬p ∧ ¬q ⟹ ¬(p ∨ q)"
apply (rule notI)
apply (erule conjE)
apply (erule disjE)
apply (erule notE, assumption)+
done

text {* ---------------------------------------------------------------
Ejercicio 48. Demostrar
¬p ∨ ¬q ⊢ ¬(p ∧ q)
------------------------------------------------------------------ *}

lemma ej48: "¬p ∨ ¬q ⟹ ¬(p ∧ q)"
apply (rule notI)
apply (erule conjE)
apply (erule disjE)
apply (erule notE, assumption)+
done

text {* ---------------------------------------------------------------
Ejercicio 49. Demostrar
⊢ ¬(p ∧ ¬p)
------------------------------------------------------------------ *}

lemma ej49: "¬(p ∧ ¬p)"
apply (rule notI)
apply (erule conjE)
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 50. Demostrar
p ∧ ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ej50: "p ∧ ¬p ⟹ q"
apply (erule conjE)
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 51. Demostrar
¬¬p ⊢ p
------------------------------------------------------------------ *}

lemma ej51: "¬¬p ⟹ p"
apply (erule notnotD)
done

text {* ---------------------------------------------------------------
Ejercicio 52. Demostrar
⊢ p ∨ ¬p
------------------------------------------------------------------ *}

lemma ej52: "p ∨ ¬p"
apply (cut_tac P="¬p" in excluded_middle)
apply (erule disjE)
apply (rule disjI1)
apply (erule notnotD)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 53. Demostrar
⊢ ((p ⟶ q) ⟶ p) ⟶ p
------------------------------------------------------------------ *}

lemma ej53: "((p ⟶ q) ⟶ p) ⟶ p"
apply (rule impI)
apply (rule ccontr)
apply (cut_tac P="p ⟶ q" in excluded_middle)
apply (erule disjE)
apply (erule_tac P="p ⟶ q" in notE)
apply (rule impI)
apply (erule notE)
apply assumption
apply (erule impE)
apply assumption
apply (erule notE)
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 54. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej54: "¬q ⟶ ¬p ⟹ p ⟶ q"
apply (rule impI)
apply (rule ccontr)
apply (erule impE)
apply assumption
apply (erule notE)+
apply assumption
done

text {* ---------------------------------------------------------------
Ejercicio 55. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej55: "¬(¬p ∧ ¬q) ⟹ p ∨ q"
apply (cut_tac P=p in excluded_middle)
apply (erule disjE)
apply (cut_tac P=q in excluded_middle)
apply (erule disjE)
apply (erule notE)
apply (rule conjI)
apply assumption+
apply (erule disjI2)
apply (erule disjI1)
done

text {* ---------------------------------------------------------------
Ejercicio 56. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ej56: "¬(¬p ∨ ¬q) ⟹ p ∧ q"
apply (rule conjI)
apply (rule ccontr)
apply (erule notE)
apply (erule disjI1)
apply (rule ccontr)
apply (erule notE)
apply (erule disjI2)
done

text {* ---------------------------------------------------------------
Ejercicio 57. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}

lemma ej57: "¬(p ∧ q) ⟹ ¬p ∨ ¬q"
apply (cut_tac P=p in excluded_middle)
apply (erule disjE)
apply (erule disjI1)
apply (cut_tac P=q in excluded_middle)
apply (erule disjE)
apply (erule disjI2)
apply (erule notE)
apply (rule conjI)
apply assumption+
done

text {* ---------------------------------------------------------------
Ejercicio 58. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ej58: "(p ⟶ q) ∨ (q ⟶ p)"
apply (cut_tac P=p in excluded_middle)
apply (erule disjE)
apply (rule disjI1)
apply (rule impI)
apply (erule notE)
apply assumption
apply (rule disjI2)
apply (rule impI)
apply assumption
done

end

</source>

Sol 8

2019-04-09T10:52:54Z

Mjoseh:

<source lang = "isabelle">
chapter {* R8: Argumentación en lógica de primer orden *}

theory R8_sol
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es formalizar en lógica de primer orden
argumentos expresados en lenguaje natural.

Antes de escribir la soluciones, comprobar con APLI2 la corrección de
la formalización.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar el 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
------------------------------------------------------------------ *}

-- "La refutación automática es"
lemma ejercicio_1:
assumes "(∃x. I(x)) ∧ (∃x. T(x))"
shows "∃x. I(x) ∧ T(x)"
quickcheck
oops

text {*
El argumento es incorrecto como muestra el siguiente contraejemplo:
I = {a1}
T = {a2}
*}

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar el siguiente argumento
Todos los participantes son vencedores. Hay como máximo un
vencedor. Hay como máximo un participante. Por lo tanto, hay
exactamente un participante.
Usar P(x) para x es un participante
V(x) para x es un vencedor
------------------------------------------------------------------ *}

-- "La refutación automática es"
lemma ejercicio_2:
assumes "∀x. P(x) ⟶ V(x)"
"∀x y. V(x) ∧ V(y) ⟶ x=y"
"∀x y. P(x) ∧ P(y) ⟶ x=y"
shows "∃x. P(x) ∧ (∀y. P(y) ⟶ x=y)"
quickcheck
oops

text {*
El argumento es incorrecto como muestra el siguiente contraejemplo:
V = {}
P = {}
*}

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar el siguiente argumento
Ningún aristócrata debe ser condenado a galeras a menos que sus
crímenes sean vergonzosos y lleve una vida licenciosa. En la ciudad
hay aristócratas que han cometido crímenes vergonzosos aunque su
forma de vida no sea licenciosa. Por tanto, hay algún aristócrata
que no está condenado a galeras.
Usar A(x) para x es aristócrata
G(x) para x está condenado a galeras
L(x) para x lleva una vida licenciosa
V(x) para x ha cometido crímenes vergonzoso
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma ejercicio_3_a:
assumes "∀x. A(x) ∧ G(x) ⟶ L(x) ∧ V(x)"
"∃x. A(x) ∧ V(x) ∧ ¬L(x)"
shows "∃x. A(x) ∧ ¬G(x)"
using assms
by metis

lemma ejercicio_3_d:
assumes "∀x. A(x) ∧ G(x) ⟶ L(x) ∧ V(x)"
"∃x. A(x) ∧ V(x) ∧ ¬L(x)"
shows "∃x. A(x) ∧ ¬G(x)"
proof-
from assms(2) obtain a where 1:"A(a) ∧ V(a) ∧ ¬L(a)" ..
hence "A(a)" ..
have "¬G(a)"
proof
assume "G(a)"
with `A(a)` have 2: "A(a) ∧ G(a)" ..
have "A(a) ∧ G(a) ⟶ L(a) ∧ V(a)" using assms(1) ..
hence "L(a) ∧ V(a)" using 2 ..
hence "L(a)" ..
have "V(a) ∧ ¬L(a)" using 1 ..
hence "¬L(a)" ..
thus False using `L(a)`..
qed
with `A(a)` have "A(a) ∧ ¬G(a)" ..
thus "∃x. A(x) ∧ ¬G(x)" ..
qed

lemma ejercicio_3_e:
"⟦∀x. A(x) ∧ G(x) ⟶ L(x) ∧ V(x);
∃x. A(x) ∧ V(x) ∧ ¬L(x)⟧ ⟹ ∃x. A(x) ∧ ¬G(x)"
apply (erule exE)
apply (erule_tac x = x in allE)
apply (rule_tac x = x in exI)
apply (rule conjI)
apply (erule conjunct1)
apply (rule notI)
apply (drule mp)
apply (rule conjI)
apply (erule conjunct1, assumption)
apply (drule conjunct2)
apply (drule conjunct1)
apply (drule conjunct2)
apply (erule notE, assumption)
done

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar el siguiente argumento
Todos los robots obedecen a los amigos del programador jefe.
Alvaro es amigo del programador jefe, pero Benito no le
obedece. Por tanto, Benito no es un robot.
Usar R(x) para x es un robot
Ob(x,y) para x obedece a y
A(x) para x es amigo del programador jefe
b para Benito
a para Alvaro
------------------------------------------------------------------ *}

lemma ejercicio_4_a:
assumes "∀x y. R(x) ∧ A(y) ⟶ Ob(x,y)"
"A(a)"
"¬Ob(b,a)"
shows "¬R(b)"
using assms
by metis

lemma ejercicio_4_b:
assumes "∀x y. R(x) ∧ A(y) ⟶ Ob(x,y)"
"A(a)"
"¬Ob(b,a)"
shows "¬R(b)"
proof
assume "R(b)"
have "∀y. R(b) ∧ A(y) ⟶ Ob(b,y)" using assms(1) ..
hence 1: "R(b) ∧ A(a) ⟶ Ob(b,a)" ..
have "R(b) ∧ A(a)" using `R(b)` assms(2) ..
with 1 have "Ob(b,a)" ..
with assms(3) show False ..
qed

lemma ejercicio_4_c:
"⟦∀x y. R(x) ∧ A(y) ⟶ Ob(x,y);
A(a);¬Ob(b,a)⟧⟹ ¬R(b)"
apply (rule notI)
apply (erule_tac x = b in allE)
apply (erule notE)
apply (erule allE)
apply (erule mp)
apply (rule conjI, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar el siguiente argumento
Ningún socio del club está en deuda con el tesorero del club. Si
un socio del club no paga su cuota está en deuda con el tesorero
del club. Por tanto, si el tesorero del club es socio del club,
entonces paga su cuota.
Usar P(x) para x es socio del club
Q(x) para x paga su cuota
R(x) para x está en deuda con el tesorero
a para el tesorero del club
------------------------------------------------------------------ *}

lemma ejercicio_5_a:
assumes "¬(∃x. P(x) ∧ R(x))"
"∀x. P(x) ∧ ¬Q(x) ⟶ R(x)"
shows "P(a) ⟶ Q(a)"
using assms
by auto

lemma ejercicio_5_b:
assumes "¬(∃x. P(x) ∧ R(x))"
"∀x. P(x) ∧ ¬Q(x) ⟶ R(x)"
shows "P(a) ⟶ Q(a)"
proof
assume "P(a)"
show "Q(a)"
proof (rule ccontr)
assume "¬Q(a)"
with `P(a)` have 1: "P(a) ∧ ¬Q(a)" ..
have "P(a) ∧ ¬Q(a) ⟶ R(a)" using assms(2) ..
hence "R(a)" using 1 ..
with `P(a)` have "P(a) ∧ R(a)" ..
hence "∃x. P(x) ∧ R(x)" ..
with assms(1) show False ..
qed
qed

lemma ejercicio_5_c:
"⟦¬(∃x. P(x) ∧ R(x));
∀x. P(x) ∧ ¬Q(x) ⟶ R(x)⟧ ⟹ P(a) ⟶ Q(a)"
apply (rule impI)
apply (erule_tac x = a in allE)
apply (rule ccontr)
apply (erule notE)
apply (rule_tac x = a in exI)
apply (rule conjI, assumption)
apply (erule mp)
apply (rule conjI, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 6. Formalizar el 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
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma ejercicio_6_a:
assumes "∀x. Af(x) ⟶ (∀y. E(y) ⟶ Ap(x,y))"
"∀x. E(x) ⟶ ¬Ap(j,x)"
shows "(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
using assms
by metis

lemma ejercicio_6_d:
assumes "∀x. Af(x) ⟶ (∀y. 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 a where "E(a) ∧ N(a)" ..
hence "E(a)" ..
have "E(a) ⟶ ¬Ap(j,a)" using assms(2) ..
hence "¬Ap(j,a)" using `E(a)` ..
show "¬Af(j)"
proof
assume "Af(j)"
have "Af(j) ⟶ (∀y. E(y) ⟶ Ap(j,y))" using assms(1) ..
hence "∀y. E(y) ⟶ Ap(j,y)" using `Af(j)` ..
hence "E(a) ⟶ Ap(j,a)" ..
hence "Ap(j,a)" using `E(a)` ..
with `¬Ap(j,a)` show False ..
qed
qed

lemma ejercicio_6_c:
"⟦∀x. Af(x) ⟶ (∀y. E(y) ⟶ Ap(x,y));
∀x. E(x) ⟶ ¬Ap(j,x)⟧ ⟹
(∃x. E(x) ∧ N(x)) ⟶ ¬Af(j)"
apply (rule impI)
apply (erule exE)
apply (erule_tac x = x in allE)
apply (erule_tac x = j in allE)
apply (rule notI)
apply (drule mp)
apply (erule conjunct1)
apply (drule mp, assumption)
apply (erule notE)
apply (drule conjunct1)
apply (erule_tac x = x in allE)
apply (erule mp, assumption)
done

text {* ---------------------------------------------------------------
Ejercicio 7. Formalizar el siguiente argumento
Todo aquel que entre en el país y no sea un VIP será cacheado por
un aduanero. Hay un contrabandista que entra en el país y que solo
podrá ser cacheado por contrabandistas. Ningún contrabandista es un
VIP. Por tanto, algún aduanero es contrabandista.
Usar A(x) para x es aduanero
Ca(x,y) para x cachea a y
Co(x) para x es contrabandista
E(x) para x entra en el pais
V(x) para x es un VIP
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma ejercicio_7_a:
assumes "∀x. E(x) ∧ ¬V(x) ⟶ (∃y. A(y) ∧ Ca(y,x))"
"∃x. Co(x) ∧ E(x) ∧ (∀y. Ca(y,x) ⟶ Co(y))"
"¬(∃x. Co(x) ∧ V(x))"
shows "∃x. A(x) ∧ Co(x)"
using assms
by metis

lemma ejercicio_7_d:
assumes "∀x. E(x) ∧ ¬V(x) ⟶ (∃y. A(y) ∧ Ca(y,x))"
"∃x. Co(x) ∧ E(x) ∧ (∀y. Ca(y,x) ⟶ Co(y))"
"¬(∃x. Co(x) ∧ V(x))"
shows "∃x. A(x) ∧ Co(x)"
proof-
from assms(2) obtain a where 1: "Co(a) ∧ E(a) ∧ (∀y. Ca(y,a) ⟶ Co(y))" ..
hence "Co(a)" ..
have 2:" E(a) ∧ (∀y. Ca(y,a) ⟶ Co(y))" using 1 ..
hence "E(a)" ..
have 3: "∀y. Ca(y,a) ⟶ Co(y)" using 2 ..
have "¬V(a) ∨ V(a)" ..
thus "∃x. A(x) ∧ Co(x)"
proof
assume "¬V(a)"
with `E(a)` have 4: "E(a) ∧ ¬V(a)" ..
have "E(a) ∧ ¬V(a) ⟶ (∃y. A(y) ∧ Ca(y,a))" using assms(1) ..
hence "∃y. A(y) ∧ Ca(y,a)" using 4 ..
then obtain b where "A(b) ∧ Ca(b,a)" ..
hence "A(b)" ..
have "Ca(b,a)" using `A(b) ∧ Ca(b,a)` ..
have "Ca(b,a) ⟶ Co(b)" using 3 ..
hence "Co(b)" using `Ca(b,a)`..
with `A(b)` have "A(b) ∧ Co(b)" ..
thus "∃x. A(x) ∧ Co(x)" ..
next
assume "V(a)"
with `Co(a) ` have "Co(a) ∧ V(a)" ..
hence "∃x. Co(x) ∧ V(x)" ..
with assms(3) show "∃x. A(x) ∧ Co(x)" ..
qed
qed

lemma ejercicio_7_c:
"⟦∀x. E(x) ∧ ¬V(x) ⟶ (∃y. A(y) ∧ Ca(y,x));
∃x. Co(x) ∧ E(x) ∧ (∀y. Ca(y,x) ⟶ Co(y));
¬(∃x. Co(x) ∧ V(x)) ⟧ ⟹ ∃x. A(x) ∧ Co(x)"
apply (erule exE)
apply (erule_tac x = x in allE)
apply (drule mp)
apply (rule conjI)
apply (drule conjunct2)
apply (drule conjunct1, assumption)
apply (rule notI)
apply (erule notE)
apply (drule conjunct1)
apply (rule_tac x = x in exI)
apply (rule conjI, assumption+)
apply (erule exE)
apply (rule_tac x = y in exI)
apply (rule conjI)
apply (erule conjunct1)+
apply (drule conjunct2)+
apply (erule_tac x = y in allE)
apply (drule mp, assumption+)
done

section {* Ejercicios con igualdad *}

text {* ---------------------------------------------------------------
Ejercicio 8. Formalizar el siguiente argumento
Rosa ama a Curro. Paco no simpatiza con Ana. Quien no simpatiza con
Ana ama a Rosa. Si una persona ama a otra, la segunda ama a la
primera. Hay como máximo una persona que ama a Rosa. Por tanto,
Paco es Curro.
Usar A(x,y) para x ama a y
S(x,y) para x simpatiza con y
a para Ana
c para Curro
p para Paco
r para Rosa
------------------------------------------------------------------ *}

lemma ejercicio_8_a:
assumes "A(r,c)"
"¬S(p,a)"
"∀x. ¬S(x,a) ⟶ A(x,r)"
"∀x y. A(x,y) ⟶ A(y,x)"
"∀x y. A(x,r) ∧ A(y,r) ⟶ x=y"
shows "p = c"
using assms
by auto

lemma ejercicio_8_b:
assumes "A(r,c)"
"¬S(p,a)"
"∀x. ¬S(x,a) ⟶ A(x,r)"
"∀x y. A(x,y) ⟶ A(y,x)"
"∀x y. A(x,r) ∧ A(y,r) ⟶ x=y"
shows "p = c"
proof-
have "∀y. A(r,y) ⟶ A(y,r)" using assms(4) ..
hence "A(r,c) ⟶ A(c,r)" ..
hence "A(c,r)" using assms(1) ..
have "¬S(p,a) ⟶ A(p,r)" using assms(3) ..
hence "A(p,r)" using assms(2) ..
hence 1: "A(p,r) ∧ A(c,r)" using `A(c,r)`..
have "∀y. A(p,r) ∧ A(y,r) ⟶ p=y" using assms(5) ..
hence "A(p,r) ∧ A(c,r) ⟶ p=c" ..
thus "p=c" using 1 ..
qed

lemma ejercicio_8_c:
"⟦A(r,c);
¬S(p,a);
∀x. ¬S(x,a) ⟶ A(x,r);
∀x y. A(x,y) ⟶ A(y,x);
∀x y. A(x,r) ∧ A(y,r) ⟶ x=y ⟧ ⟹ p = c"
apply (drule_tac x = p in spec)
apply (drule mp, assumption)
apply (drule_tac x = r in spec)
apply (drule_tac x = p in spec)
apply (frule_tac x = c in spec)
apply (drule mp, assumption)
apply (drule_tac x = c in spec)+
apply (rule mp, assumption)
apply (rule conjI, assumption+)
done

text {* ---------------------------------------------------------------
Ejercicio 9. Formalizar el siguiente argumento
Todos los filósofos se han preguntado qué es la filosofía. Los que
se preguntan qué es la filosofía se vuelven locos. Nietzsche es
filósofo. El maestro de Nietzsche no acabó loco. Por tanto,
Nietzsche y su maestro son diferentes personas.
Usar F(x) para x es filósofo
L(x) para x se vuelve loco
P(x) para x se ha preguntado qué es la filosofía.
m para el maestro de Nietzsche
n para Nietzsche
------------------------------------------------------------------ *}

lemma ejercicio_9_a:
assumes "∀x. F(x) ⟶ P(x)"
"∀x. P(x) ⟶ L(x)"
"F(n)"
"¬L(m)"
shows "n ≠ m"
using assms
by auto

lemma ejercicio_9_b:
assumes "∀x. F(x) ⟶ P(x)"
"∀x. P(x) ⟶ L(x)"
"F(n)"
"¬L(m)"
shows "n ≠ m"
proof
assume "n = m"
hence "F(m)" using assms(3) by (rule subst)
have "F(m) ⟶ P(m)" using assms(1) ..
hence "P(m)" using `F(m)` ..
have "P(m) ⟶ L(m)" using assms(2) ..
hence "L(m)" using `P(m)` ..
with assms(4) show False ..
qed

lemma ejercicio_9_c:
"⟦∀x. F(x) ⟶ P(x);
∀x. P(x) ⟶ L(x);
F(n);
¬L(m) ⟧ ⟹ n ≠ m"
apply (rule notI)
apply (erule_tac x = n in allE)
apply (drule mp, assumption)
apply (erule_tac x = m in allE)
apply (erule notE)
apply (erule mp)
apply (erule subst, assumption)
done

text {* ---------------------------------------------------------------
Ejercicio 10. Formalizar el siguiente argumento
Eduardo pudo haber visto al asesino. Antonio fue el primer testigo
de la defensa. O Eduardo estaba en clase o Antonio dio falso
testimonio. Nadie en clase pudo haber visto al asesino. Luego, el
primer testigo de la defensa dio falso testimonio.
Usar C(x) para x estaba en clase
F(x) para x dio falso testimonio
V(x) para x pudo haber visto al asesino
a para Antonio
e para Eduardo
p para el primer testigo de la defensa
------------------------------------------------------------------ *}

lemma ejercicio_10_a:
assumes "V(e)"
"a = p"
"C(e) ∨ F(a)"
"∀x. C(x) ⟶ ¬V(x)"
shows "F(p)"
using assms
by auto

lemma ejercicio_10_b:
assumes "V(e)"
"a = p"
"C(e) ∨ F(a)"
"∀x. C(x) ⟶ ¬V(x)"
shows "F(p)"
using assms(3)
proof
assume "C(e)"
have "C(e) ⟶ ¬V(e)" using assms(4) ..
hence "¬V(e)" using `C(e)` ..
thus "F(p)" using assms(1) ..
next
assume "F(a)"
with assms(2) show "F(p)" by (rule subst)
qed

lemma ejercicio_10_c:
"⟦ V(e);
a = p;
C(e) ∨ F(a);
∀x. C(x) ⟶ ¬V(x) ⟧ ⟹ F(p)"
apply (erule disjE)
apply (erule_tac x = e in allE)
apply (drule mp, assumption)
apply (erule notE, assumption)
apply (erule subst, assumption)
done

end

</source>

Sol 8

2019-04-09T10:52:44Z

Mjoseh:

Sol 7

2019-04-09T10:52:00Z

Mjoseh:

Sol 6

2019-04-09T10:51:16Z

Mjoseh:

<source lang = "isabelle">
chapter {* R6: Deducción natural en lógica de de primer orden *}

theory R6_sol
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
. excluded_middel:(¬P ∨ P)

· allE: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
· allI: (⋀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 y mt que demostramos a continuación.
*}

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

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

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

lemma ejercicio_1a:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. P x) ⟶ (∀x. Q x)"
proof
assume "∀x. P x"
show "∀x. Q x"
proof
fix a
have "P a" using `∀x. P x` by (rule allE)
have "P a ⟶ Q a" using assms ..
thus "Q a" using `P a` ..
qed
qed

lemma ejercicio_1b:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. P x) ⟶ (∀x. Q x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
∃x. ¬(P x) ⊢ ¬(∀x. P x)
------------------------------------------------------------------ *}

lemma ejercicio_2a:
assumes "∃x. ¬(P x)"
shows "¬(∀x. P x)"
proof
assume "∀x. P x"
obtain a where "¬(P a)" using assms ..
have "P a" using `∀x. P x` ..
with `¬(P a)` show False ..
qed

lemma ejercicio_2b:
assumes "∃x. ¬(P x)"
shows "¬(∀x. P x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
∀x. P x ⊢ ∀y. P y
------------------------------------------------------------------ *}

lemma ejercicio_3a:
assumes "∀x. P x"
shows "∀y. P y"
proof
fix a show "P a" using assms ..
qed

lemma ejercicio_3b:
assumes "∀x. P x"
shows "∀y. P y"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
∀x. P x ⟶ Q x ⊢ (∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))
------------------------------------------------------------------ *}

lemma ejercicio_4a:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))"
proof
assume "∀x. ¬(Q x)"
show "∀x. ¬ (P x)"
proof
fix a
have "¬(Q a)" using `∀x. ¬(Q x)` ..
have "P a ⟶ Q a" using assms ..
thus "¬(P a)" using `¬(Q a)` by (rule mt)
qed
qed

lemma ejercicio_4b:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
∀x. P x ⟶ ¬(Q x) ⊢ ¬(∃x. P x ∧ Q x)
------------------------------------------------------------------ *}

lemma ejercicio_5a:
assumes "∀x. P x ⟶ ¬(Q x)"
shows "¬(∃x. P x ∧ Q x)"
proof
assume "∃x. P x ∧ Q x"
then obtain a where "P a ∧ Q a" ..
hence "P a" ..
have "P a ⟶ ¬(Q a)" using assms ..
hence "¬(Q a)" using `P a` ..
have "Q a" using `P a ∧ Q a` ..
with `¬(Q a)` show False ..
qed

lemma ejercicio_5b:
assumes "∀x. P x ⟶ ¬(Q x)"
shows "¬(∃x. P x ∧ Q x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
∀x y. P x y ⊢ ∀u v. P u v
------------------------------------------------------------------ *}

lemma ejercicio_6a:
assumes "∀x y. P x y"
shows "∀u v. P u v"
proof (rule allI)+
fix a b
have "∀y. P a y" using assms ..
thus "P a b" ..
qed

lemma ejercicio_6b:
assumes "∀x y. P x y"
shows "∀u v. P u v"
proof (rule allI)
fix a
show "∀y. P a y" using assms ..
qed

lemma ejercicio_6c:
assumes "∀x y. P x y"
shows "∀u v. P u v"
proof
fix a
show "∀y. P a y" using assms ..
qed

lemma ejercicio_6d:
assumes "∀x y. P x y"
shows "∀u v. P u v"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
∃x y. P x y ⟹ ∃u v. P u v
------------------------------------------------------------------ *}

lemma ejercicio_7a:
assumes "∃x y. P x y"
shows "∃u v. P u v"
proof -
obtain a where "∃y. P a y" using assms ..
then obtain b where "P a b" ..
hence "∃v. P a v" ..
thus "∃u v. P u v" ..
qed

lemma ejercicio_7c:
assumes "∃x y. P x y"
shows "∃u v. P u v"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
∃x. ∀y. P x y ⊢ ∀y. ∃x. P x y
------------------------------------------------------------------ *}

lemma ejercicio_8a:
assumes "∃x. ∀y. P x y"
shows "∀y. ∃x. P x y"
proof
fix b
obtain a where "∀y. P a y" using assms ..
hence "P a b" ..
thus "∃x. P x b" ..
qed

lemma ejercicio_8b:
assumes "∃x. ∀y. P x y"
shows "∀y. ∃x. P x y"
using assms by auto

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

lemma ejercicio_9a:
assumes "∃x. P a ⟶ Q x"
shows "P a ⟶ (∃x. Q x)"
proof
assume "P a"
obtain b where "P a ⟶ Q b" using assms ..
hence "Q b" using `P a`..
thus "∃x . Q x" ..
qed

lemma ejercicio_9b:
assumes "∃x. P a ⟶ Q x"
shows "P a ⟶ (∃x. Q x)"
using assms by auto

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

lemma ejercicio_10a:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
have "¬(P a) ∨ (P a)" ..
thus "∃x. P a ⟶ Q x"
proof
assume "¬(P a)"
have "P a ⟶ Q a"
proof
assume "P a"
with `¬(P a)` show "Q a" ..
qed
thus "∃x. P a ⟶ Q x" ..
next
assume "P a"
with assms have "∃x. Q x" ..
then obtain b where "Q b" ..
hence "P a ⟶ Q b" ..
thus "∃x. P a ⟶ Q x" ..
qed
qed

lemma ejercicio_10b:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
using assms by auto

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

lemma ejercicio_11a:
assumes "(∃x. P x) ⟶ Q a"
shows "∀x. P x ⟶ Q a"
proof
fix b
show "P b ⟶ Q a"
proof
assume "P b"
hence "∃x. P x" ..
with assms show "Q a" ..
qed
qed

lemma ejercicio_11b:
assumes "(∃x. P x) ⟶ Q a"
shows "∀x. P x ⟶ Q a"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
∀x. P x ⟶ Q a ⊢ ∃ x. P x ⟶ Q a
------------------------------------------------------------------ *}

lemma ejercicio_12a:
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
proof - (* comentar sin - *)
have "P b ⟶ Q a" using assms .. (* ¿universo? *)
thus "∃x. P x ⟶ Q a" ..
qed

lemma ejercicio_12b:
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
(∀x. P x) ∨ (∀x. Q x) ⊢ ∀x. P x ∨ Q x
------------------------------------------------------------------ *}

lemma ejercicio_13a:
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
using assms
proof
assume "∀x. P x"
show "∀x. P x ∨ Q x"
proof
fix a
have "P a" using `∀x. P x` ..
thus "P a ∨ Q a" ..
qed
next
assume "∀x. Q x"
show "∀x. P x ∨ Q x"
proof
fix a
have "Q a" using `∀x. Q x` ..
thus "P a ∨ Q a" ..
qed
qed

lemma ejercicio_13b:
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
proof
fix a
note assms
thus "P a ∨ Q a"
proof
assume "∀x. P x"
hence "P a" ..
thus "P a ∨ Q a" ..
next
assume "∀x. Q x"
hence "Q a" ..
thus "P a ∨ Q a" ..
qed
qed

lemma ejercicio_13c:
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
∃x. P x ∧ Q x ⊢ (∃x. P x) ∧ (∃x. Q x)
------------------------------------------------------------------ *}

lemma ejercicio_14a:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
proof
show "∃x. P x"
proof -
obtain a where "P a ∧ Q a" using assms ..
hence "P a" ..
thus "∃x. P x" ..
qed
next
show "∃x. Q x"
proof -
obtain a where "P a ∧ Q a" using assms ..
hence "Q a" ..
thus "∃x. Q x" ..
qed
qed

lemma ejercicio_14b:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
proof
obtain a where "P a ∧ Q a" using assms ..
hence "P a" ..
thus "∃x. P x" ..
next
obtain a where "P a ∧ Q a" using assms ..
hence "Q a" ..
thus "∃x. Q x" ..
qed

lemma ejercicio_14c:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
proof -
obtain a where "P a ∧ Q a" using assms ..
{have "∃x. P x"
proof -
have "P a" using `P a ∧ Q a` ..
thus "∃x. P x" ..
qed}
moreover
{have "∃x. Q x"
proof -
have "Q a" using `P a ∧ Q a` ..
thus "∃x. Q x" ..
qed}
ultimately show "(∃x. P x) ∧ (∃x. Q x)" ..
qed

lemma ejercicio_14d:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
∀x y. P y ⟶ Q x ⊢ (∃y. P y) ⟶ (∀x. Q x)
------------------------------------------------------------------ *}

lemma ejercicio_15a:
assumes "∀x y. P y ⟶ Q x"
shows "(∃y. P y) ⟶ (∀x. Q x)"
proof
assume "∃y. P y"
then obtain b where "P b" ..
show "∀x. Q x"
proof
fix a
have "∀y. P y ⟶ Q a" using assms ..
hence "P b ⟶ Q a" ..
thus "Q a" using `P b` ..
qed
qed

lemma ejercicio_15b:
assumes "∀x y. P y ⟶ Q x"
shows "(∃y. P y) ⟶ (∀x. Q x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
¬(∀x. ¬(P x)) ⊢ ∃x. P x
------------------------------------------------------------------ *}

lemma ejercicio_16a:
assumes "¬(∀x. ¬(P x))"
shows "∃x. P x"
proof (rule ccontr)
assume "¬(∃x. P x)"
have "∀x. ¬(P x)"
proof
fix a
show "¬(P a)"
proof
assume "P a"
hence "∃x. P x" ..
with `¬(∃x. P x)` show False ..
qed
qed
with assms show False ..
qed

lemma ejercicio_16b:
assumes "¬(∀x. ¬(P x))"
shows "∃x. P x"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
∀x. ¬(P x) ⊢ ¬(∃x. P x)
------------------------------------------------------------------ *}

lemma ejercicio_17a:
assumes "∀x. ¬(P x)"
shows "¬(∃x. P x)"
proof
assume "∃x. P x"
then obtain a where "P a " ..
have "¬(P a)" using assms ..
thus False using `P a` ..
qed

lemma ejercicio_17b:
assumes "∀x. ¬(P x)"
shows "¬(∃x. P x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
∃x. P x ⊢ ¬(∀x. ¬(P x))
------------------------------------------------------------------ *}

lemma ejercicio_18a:
assumes "∃x. P x"
shows "¬(∀x. ¬(P x))"
proof
obtain a where "P a" using assms ..
assume "∀x. ¬(P x)"
hence "¬(P a)" ..
thus False using `P a` ..
qed

lemma ejercicio_18b:
assumes "∃x. P x"
shows "¬(∀x. ¬(P x))"
using assms by auto

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

lemma ejercicio_19a:
assumes "P a ⟶ (∀x. Q x)"
shows "∀x. P a ⟶ Q x"
proof
fix b
show "P a ⟶ Q b"
proof
assume "P a"
with assms have "∀x. Q x" ..
thus "Q b" ..
qed
qed

lemma ejercicio_19b:
assumes "P a ⟶ (∀x. Q x)"
shows "∀x. P a ⟶ Q x"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 20. 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)
------------------------------------------------------------------ *}

lemma ejercicio_20a:
assumes "∀x y z. R x y ∧ R y z ⟶ R x z"
"∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)+
fix a b
show "R a b ⟶ ¬(R b a)"
proof
assume "R a b"
show "¬(R b a)"
proof
assume "R b a"
with `R a b` have "R a b ∧ R b a" ..
have "¬(R a a)" using assms(2) ..
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) ..
hence "∀z. R a b ∧ R b z ⟶ R a z" ..
hence "R a b ∧ R b a ⟶ R a a" ..
hence "R a a" using `R a b ∧ R b a` ..
with `¬(R a a)` show False ..
qed
qed
qed

lemma ejercicio_20b:
"⟦∀x y z. R x y ∧ R y z ⟶ R x z; ∀x. ¬(R x x)⟧ ⟹ ∀x y. R x y ⟶ ¬(R y x)"
by metis

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
{∀x. P x ∨ Q x, ∃x. ¬(Q x), ∀x. R x ⟶ ¬(P x)} ⊢ ∃x. ¬(R x)
------------------------------------------------------------------ *}

lemma ejercicio_21a:
assumes "∀x. P x ∨ Q x"
"∃x. ¬(Q x)"
"∀x. R x ⟶ ¬(P x)"
shows "∃x. ¬(R x)"
proof -
obtain a where "¬(Q a)" using assms(2) ..
have "P a ∨ Q a" using assms(1) ..
hence "¬(R a)"
proof
assume "P a"
hence "¬¬(P a)" by (rule notnotI)
have "R a ⟶ ¬(P a)" using assms(3) ..
thus "¬(R a)" using `¬¬(P a)` by (rule mt)
next
assume "Q a"
with `¬(Q a)` show "¬(R a)" ..
qed
thus "∃x. ¬(R x)" ..
qed

lemma ejercicio_21b:
assumes "∀x. P x ∨ Q x"
"∃x. ¬(Q x)"
"∀x. R x ⟶ ¬(P x)"
shows "∃x. ¬(R x)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
{∀x. P x ⟶ Q x ∨ R x, ¬(∃x. P x ∧ R x)} ⊢ ∀x. P x ⟶ Q x
------------------------------------------------------------------ *}

lemma ejercicio_22a:
assumes "∀x. P x ⟶ Q x ∨ R x"
"¬(∃x. P x ∧ R x)"
shows "∀x. P x ⟶ Q x"
proof
fix a
show "P a ⟶ Q a"
proof
assume "P a"
have "P a ⟶ Q a ∨ R a" using assms(1) ..
hence "Q a ∨ R a" using `P a` ..
thus "Q a"
proof
assume "Q a" thus "Q a" .
next
assume "R a"
with `P a` have "P a ∧ R a" ..
hence "∃x. P x ∧ R x" ..
with assms(2) show "Q a" ..
qed
qed
qed

lemma ejercicio_22b:
assumes "∀x. P x ⟶ Q x ∨ R x"
"¬(∃x. P x ∧ R x)"
shows "∀x. P x ⟶ Q x"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
∃x y. R x y ∨ R y x ⊢ ∃x y. R x y
------------------------------------------------------------------ *}

lemma ejercicio_23a:
assumes "∃x y. R x y ∨ R y x"
shows "∃x y. R x y"
proof -
obtain a where "∃y. R a y ∨ R y a" using assms ..
then obtain b where "R a b ∨ R b a" ..
thus "∃x y. R x y"
proof
assume "R a b"
hence "∃y. R a y" ..
thus "∃x y. R x y" ..
next
assume "R b a"
hence "∃y. R b y" ..
thus "∃x y. R x y" ..
qed
qed

lemma ejercicio_23b:
assumes "∃x y. R x y ∨ R y x"
shows "∃x y. R x y"
using assms by auto

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

lemma ejercicio_24a:
"(∃x. ∀y. P x y) ⟶ (∀y. ∃x. P x y)"
proof
assume "∃x. ∀y. P x y"
then obtain a where "∀y. P a y" ..
show "∀y. ∃x. P x y"
proof
fix b
have "P a b" using `∀y. P a y` ..
thus "∃x. P x b" ..
qed
qed

lemma ejercicio_24b:
"(∃x. ∀y. P x y) ⟶ (∀y. ∃x. P x y)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)
------------------------------------------------------------------ *}

lemma ejercicio_25a:
"(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)"
proof
assume "∀x. P x ⟶ Q"
show "(∃x. P x) ⟶ Q"
proof
assume "∃x. P x"
then obtain a where "P a" ..
have "P a ⟶ Q" using `∀x. P x ⟶ Q` ..
thus "Q" using `P a` ..
qed
next
assume "(∃x. P x) ⟶ Q"
show "∀x. P x ⟶ Q"
proof
fix a
show "P a ⟶ Q"
proof
assume "P a"
hence "∃x. P x" ..
with `(∃x. P x) ⟶ Q` show "Q" ..
qed
qed
qed

lemma ejercicio_25b:
"(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)
------------------------------------------------------------------ *}

lemma ejercicio_26a:
"((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)"
proof
assume "(∀x. P x) ∧ (∀x. Q x)"
hence "∀x. P x" ..
have "∀x. Q x" using `(∀x. P x) ∧ (∀x. Q x)` ..
show "∀x. P x ∧ Q x"
proof
fix a
have "Q a" using `∀x. Q x` ..
have "P a" using `∀x. P x` ..
thus "P a ∧ Q a" using `Q a` ..
qed
next
assume "∀x. P x ∧ Q x"
show "(∀x. P x) ∧ (∀x. Q x)"
proof
show "∀x. P x"
proof
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` ..
thus "P a" ..
qed
next
show "∀x. Q x"
proof
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` ..
thus "Q a" ..
qed
qed
qed

lemma ejercicio_26b:
"((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar o refutar
((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)
------------------------------------------------------------------ *}

lemma ejercicio_27a:
"((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)"
nitpick

(* Nitpicking formula... *)

(* Nitpick found a counterexample for card 'a = 2: *)

(* Free variables: *)
(* P = (λx. _)(a\<^isub>1 := False, a\<^isub>2 := True) *)
(* Q = (λx. _)(a\<^isub>1 := True, a\<^isub>2 := False) *)
oops

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar o refutar
((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)
------------------------------------------------------------------ *}

lemma ejercicio_28a:
"((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)"
by auto

lemma ejercicio_28b:
"((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)"
proof
assume "(∃x. P x) ∨ (∃x. Q x)"
thus "∃x. P x ∨ Q x"
proof
assume "∃x. P x"
then obtain a where "P a" ..
hence "P a ∨ Q a" ..
thus "∃x. P x ∨ Q x" ..
next
assume "∃x. Q x"
then obtain a where "Q a" ..
hence "P a ∨ Q a" ..
thus "∃x. P x ∨ Q x" ..
qed
next
assume "∃x. P x ∨ Q x"
then obtain a where "P a ∨ Q a" ..
thus "(∃x. P x) ∨ (∃x. Q x)"
proof
assume "P a"
hence "∃x. P x" ..
thus "(∃x. P x) ∨ (∃x. Q x)" ..
next
assume "Q a"
hence "∃x. Q x" ..
thus "(∃x. P x) ∨ (∃x. Q x)" ..
qed
qed

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

lemma ejercicio_29:

"(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
nitpick

(*
Nitpicking formula...

Nitpick found a counterexample for card 'a = 2 and card 'b = 2:

Free variable:
P = (λx. _)
(a\<^isub>1 := (λx. _)(b\<^isub>1 := False, b\<^isub>2 := True),
a\<^isub>2 := (λx. _)(b\<^isub>1 := True, b\<^isub>2 := False))
Skolem constants:
λy. x = (λx. _)(b\<^isub>1 := a\<^isub>1, b\<^isub>2 := a\<^isub>2)
λx. y = (λx. _)(a\<^isub>1 := b\<^isub>2, a\<^isub>2 := b\<^isub>1)
*)
oops

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar o refutar
(¬(∀x. P x)) ⟷ (∃x. ¬P x)
------------------------------------------------------------------ *}

lemma ejercicio_30a:
"(¬(∀x. P x)) ⟷ (∃x. ¬P x)"
by auto

lemma ejercicio_30b:
"(¬(∀x. P x)) ⟷ (∃x. ¬P x)"
proof
assume "¬(∀x. P x)"
show "∃x. ¬P x"
proof (rule ccontr)
assume "¬(∃x. ¬P x)"
have "∀x. P x"
proof
fix a show "P a"
proof (rule ccontr)
assume "¬(P a)"
hence "∃x. ¬P x" ..
with `¬(∃x. ¬P x)` show False ..
qed
qed
with `¬(∀x. P x)` show False ..
qed
next
assume "∃x. ¬P x"
then obtain a where "¬ (P a)" ..
show "¬ (∀x. P x)"
proof
assume "∀x. P x"
hence "P a" ..
with `¬ (P a)` show False ..
qed
qed

section {* Ejercicios sobre igualdad *}

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar o refutar
P a ⟹ ∀x. x = a ⟶ P x
------------------------------------------------------------------ *}

lemma ejercicio_31a:
assumes "P a"
shows "∀x. x = a ⟶ P x"
using assms by auto

lemma ejercicio_31b:
assumes "P a"
shows "∀x. x = a ⟶ P x"
proof
fix b
show "b = a ⟶ P b"
proof
assume "b = a" thus "P b" using assms by (rule ssubst)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar o refutar
∃x y. R x y ∨ R y x; ¬(∃x. R x x)⟧ ⟹ ∃x y. x ≠ y
------------------------------------------------------------------ *}

lemma ejercicio_32a:
fixes R :: "'c ⇒ 'c ⇒ bool"
assumes "∃x y. R x y ∨ R y x"
"¬(∃x. R x x)"
shows "∃(x::'c) y. x ≠ y"
using assms by metis

lemma ejercicio_32b:
fixes R :: "'c ⇒ 'c ⇒ bool"
assumes "∃x y. R x y ∨ R y x"
"¬(∃x. R x x)"
shows "∃(x::'c) y. x ≠ y"
proof -
from assms(1) obtain a where "∃y. R a y ∨ R y a" ..
then obtain b where "R a b ∨ R b a" ..
thus "∃(x::'c) y. x ≠ y"
proof
assume "R a b"
have "¬(a = b)"
proof
assume "a = b"
hence "R a a" using `R a b` by (rule ssubst)
hence "∃x. R x x" ..
with assms(2) show False ..
qed
hence "∃y. a ≠ y" ..
thus "∃(x::'c) y. x ≠ y" ..
next
assume "R b a"
have "¬(a = b)"
proof
assume "a = b"
hence "R a a" using `R b a` by (rule ssubst)
hence "∃x. R x x" ..
with assms(2) show False ..
qed
hence "∃y. a ≠ y" ..
thus "∃(x::'c) y. x ≠ y" ..
qed
qed

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

lemma ejercicio_33a:
assumes "∀x. P a x x"
"∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "P (f a) a (f a)"
using assms by auto

lemma ejercicio_33b:
assumes "∀x. P a x x"
"∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "P (f a) a (f a)"
proof -
have "P a a a" using assms(1) ..
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) ..
hence "∀z. P a a z ⟶ P (f a) a (f z)" ..
hence "P a a a ⟶ P (f a) a (f a)" ..
thus "P (f a) a (f a)" using `P a a a` ..
qed

text {* ---------------------------------------------------------------
Ejercicio 34. 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))
------------------------------------------------------------------ *}

lemma ejercicio_34a:
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))"
using assms by metis

lemma ejercicio_34b:
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 "P a (f a) (f a)" using assms(1) ..
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) ..
hence "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" ..
hence "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" ..
hence "P (f a) (f a) (f (f a))" using `P a (f a) (f a)` ..
thus "∃z. P (f a) z (f (f a))" ..
qed

text {* ---------------------------------------------------------------
Ejercicio 35. 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))
------------------------------------------------------------------ *}

lemma ejercicio_35a:
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))"
using assms by metis

lemma ejercicio_35b:
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 "Q a (s a)" using assms(1) ..
have "∀y. Q a y ⟶ Q (s a) (s y)" using assms(2) ..
hence "Q a (s a) ⟶ Q (s a) (s (s a))" ..
hence "Q (s a) (s (s a))" using `Q a (s a)` ..
with `Q a (s a)` have "Q a (s a) ∧ Q (s a) (s (s a))" ..
thus "∃z. Q a z ∧ Q z (s (s a))" ..
qed

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar o refutar
{x = f x, odd (f x)} ⊢ odd x
------------------------------------------------------------------ *}

lemma ejercicio_36a:
"⟦x = f x; odd (f x)⟧ ⟹ odd x"
by auto

lemma ejercicio_36b:
assumes "x = f x" and
"odd (f x)"
shows "odd x"
proof -
show "odd x" using assms by (rule ssubst)
qed

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar o refutar
{x = f x, triple (f x) (f x) x} ⊢ triple x x x
------------------------------------------------------------------ *}

lemma ejercicio_37a:
"⟦x = f x; triple (f x) (f x) x⟧ ⟹ triple x x x"
by auto

lemma ejercicio_37b:
assumes "x = f x" and
"triple (f x) (f x) x"
shows "triple x x x"
proof -
show "triple x x x" using assms by (rule ssubst)
qed

lemma ej_8_8_26:
assumes 1:"∀x. P x ⟶ ((∃y. Q x y) ⟶ (∃y. Q y x)) " and
2:"∀x. (∃y. Q y x) ⟶ Q x x" and
3: "¬ (∃x. Q x x)"
shows "∀x. P x ⟶ (∀y. (¬ Q x y))"
proof
fix a
show "P a ⟶ (∀y. (¬ Q a y))"
proof
assume "P a"
show "∀y. (¬ Q a y)"
proof
fix b
show "¬ Q a b"
proof
assume "Q a b"
hence 4:"∃y. Q a y" ..
have "P a ⟶ ((∃y. Q a y) ⟶ (∃y. Q y a))" using 1 ..
hence "(∃y. Q a y) ⟶ (∃y. Q y a)" using `P a` ..
hence 5:"∃y. Q y a" using 4 ..
have "(∃y. Q y a) ⟶ Q a a" using 2 ..
hence "Q a a" using 5 ..
hence "∃x. Q x x" ..
with 3 show False ..
qed
qed
qed
qed

end

</source>

Sol 6

2019-04-09T10:51:00Z

Mjoseh:

Sol 4

2019-04-09T10:50:20Z

Mjoseh:

<source lang = "isabelle">
chapter {* R4: Deducción natural proposicional *}

theory R4_sol
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es demostrar cada uno de los ejercicios
usando sólo las reglas básicas de deducción natural de la lógica
proposicional (sin usar el método auto).

Las reglas básicas de la deducción natural son las siguientes:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· notnotI: P ⟹ ¬¬ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
· 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
· excluded_middle: ¬P ∨ P
---------------------------------------------------------------------
*}

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

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

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

section {* Implicaciones *}

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
p ⟶ q, p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_1a:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
proof -
show "q" using 1 2 by (rule mp)
qed

lemma ejercicio_1b:
assumes "p ⟶ q"
"p"
shows "q"
proof -
show "q" using assms by (rule mp)
qed

lemma ejercicio_1c:
assumes "p ⟶ q"
"p"
shows "q"
proof -
show "q" using assms ..
qed

lemma ejercicio_1d:
assumes "p ⟶ q"
"p"
shows "q"
proof -
show "q" using assms by auto
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
p ⟶ q, q ⟶ r, p ⊢ r
------------------------------------------------------------------ *}

lemma ejercicio_2a:
assumes 1:"p ⟶ q" and
2:"q ⟶ r" and
3:"p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show 5: "r" using 2 4 by (rule mp)
qed

lemma ejercicio_2b:
assumes 1:"p ⟶ q" and
2:"q ⟶ r" and
3:"p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed

lemma ejercicio_2c:
assumes "p ⟶ q" and
"q ⟶ r" and
"p"
shows "r"
proof -
have "q" using assms(1,3) ..
show "r" using assms(2) `q` ..
qed

lemma ejercicio_2d:
assumes "p ⟶ q" and
"q ⟶ r" and
"p"
shows "r"
proof -
show "r" using assms by auto
qed

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r
------------------------------------------------------------------ *}

lemma ejercicio_3a:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p ⟶ q" and
3: "p"
shows "r"
proof -
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show 6: "r" using 4 5 by (rule mp)
qed

lemma ejercicio_3b:
assumes "p ⟶ (q ⟶ r)" and
"p ⟶ q" and
"p"
shows "r"
proof -
have 4: "q ⟶ r" using assms(1,3) ..
have "q" using assms(2,3) ..
show "r" using 4 `q` ..
qed

lemma ejercicio_3c:
assumes "p ⟶ (q ⟶ r)" and
"p ⟶ q" and
"p"
shows "r"
proof -
have "q" using assms(2,3) ..
have "q ⟶ r" using assms(1,3) ..
thus "r" using `q` ..
qed

lemma ejercicio_3d:
assumes "p ⟶ (q ⟶ r)" and
"p ⟶ q" and
"p"
shows "r"
proof -
show "r" using assms by auto
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
p ⟶ q, q ⟶ r ⊢ p ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_4a:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof -
{assume 3:"p"
have 4: "q" using 1 3 by (rule mp)
have 5: "r" using 2 4 by (rule mp)}
thus "p⟶ r" by (rule impI)
qed

lemma ejercicio_4b:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof (rule impI)
assume 3:"p"
have "q" using 1 3 by (rule mp)
show "r" using 2 `q` by (rule mp)
qed

lemma ejercicio_4c:
assumes "p ⟶ q" and
"q ⟶ r"
shows "p ⟶ r"
proof (rule impI)
assume "p"
have "q" using assms(1) `p` ..
show "r" using assms(2) `q` ..
qed

lemma ejercicio_4d:
assumes "p ⟶ q" and
"q ⟶ r"
shows "p ⟶ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_5a:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{assume 3: "q"
{assume 4: "p"
have "q ⟶ r" using 1 4 ..
hence 5: "r" using 3 ..}
hence 6: "p ⟶ r" by (rule impI)}
thus "q ⟶ (p ⟶ r)" by (rule impI)
qed

lemma ejercicio_5b:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume "q"
show "p ⟶ r"
proof (rule impI)
assume "p"
have "q ⟶ r" using assms(1) `p` ..
thus "r" using `q` ..
qed
qed

lemma ejercicio_5c:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume "q"
show "p ⟶ r"
proof
assume "p"
with assms(1) have "q ⟶ r" ..
thus "r" using `q` ..
qed
qed

lemma ejercicio_5d:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_6a:
assumes 1: "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof -
{assume 2: "p ⟶ q"
{assume 3: "p"
have 4: "q ⟶ r" using 1 3 ..
have 5: "q" using 2 3 ..
have "r" using 4 5 ..}
hence "p ⟶ r" by (rule impI)}
thus "(p ⟶ q) ⟶ (p ⟶ r)" by (rule impI)
qed

lemma ejercicio_6b:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume "p"
with `p ⟶ q` have "q" ..
have "q ⟶ r" using assms(1) `p` ..
thus "r" using `q` ..
qed
qed

lemma ejercicio_6c:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
p ⊢ q ⟶ p
------------------------------------------------------------------ *}

lemma ejercicio_7:
assumes "p"
shows "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using assms(1) by this
qed

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
⊢ p ⟶ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ejercicio_8a:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume "p"
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using `p` .
qed
qed

lemma ejercicio_8b:
"p ⟶ (q ⟶ p)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 9. Demostrar
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_9a:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof (rule impI)
assume "q ⟶ r"
show "p ⟶ r"
proof (rule impI)
assume "p"
have "q" using assms(1) `p` ..
show "r" using `q ⟶ r` `q` ..
qed
qed

lemma ejercicio_9b:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))
------------------------------------------------------------------ *}

lemma ejercicio_10a:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof (rule impI)
assume "r"
show "q ⟶ (p ⟶ s)"
proof (rule impI)
assume "q"
show "p ⟶ s"
proof (rule impI)
assume "p"
with assms(1) have "q ⟶ (r ⟶ s)" ..
hence "r ⟶ s" using `q` ..
thus "s" using `r` ..
qed
qed
qed

lemma ejercicio_10b:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 11. Demostrar
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))
------------------------------------------------------------------ *}

lemma ejercicio_11a:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume "p"
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p`..
have "q" using `p ⟶ q` `p` ..
show "r" using `q ⟶ r` `q` ..
qed
qed
qed

lemma ejercicio_11b:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ (q ⟶ r)"
{assume "p ⟶ q"
{assume "p"
with `p ⟶ q` have "q" ..
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` ..
hence "r" using `q` ..}
hence "p ⟶ r" ..}
thus "(p ⟶ q) ⟶ (p ⟶ r)" ..
qed

lemma ejercicio_11c:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
by auto

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_12a:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume "p"
show "q ⟶ r"
proof (rule impI)
assume "q"
show "r"
proof -
{assume "p"
have "q" using `q` .}
hence "p ⟶ q" ..
show "r" using assms(1) `p ⟶ q` ..
qed
qed
qed

lemma ejercicio_12b:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
{assume "q"
{assume "p"
have "q" using `q` .}
hence "p ⟶ q" ..
with assms(1) have "r" ..}
thus "q ⟶ r" ..
qed

lemma ejercicio_12c:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
using assms by auto

section {* Conjunciones *}

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
p, q ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ejercicio_13a:
assumes 1:"p" and
2:"q"
shows "p ∧ q"
proof -
show "p ∧ q" using 1 2 by (rule conjI)
qed

lemma ejercicio_13b:
assumes "p" and
"q"
shows "p ∧ q"
proof (rule conjI)
show "p" using assms(1) .
show "q" using assms(2) .
qed

lemma ejercicio_13c:
assumes "p" and
"q"
shows "p ∧ q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
p ∧ q ⊢ p
------------------------------------------------------------------ *}
lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
proof -
show "p" using assms by (rule conjunct1)
qed

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
p ∧ q ⊢ q
------------------------------------------------------------------ *}
lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
proof -
show "q" using assms by (rule conjunct2)
qed

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r
------------------------------------------------------------------ *}

lemma ejercicio_16a:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q)∧ r"
proof -
have 1: "p" using assms by (rule conjunct1)
have 2: "(q ∧ r)" using assms by (rule conjunct2)
have 3: "q" using 2 by (rule conjunct1)
have 4: "r" using 2 by (rule conjunct2)
have 5: "(p∧q)" using 1 3 by (rule conjI)
show "(p∧q) ∧ r" using 5 4 by (rule conjI)
qed

lemma ejercicio_16b:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q)∧ r"
proof (rule conjI)
show "p ∧ q"
proof (rule conjI)
show "p" using assms ..
next
have "q ∧ r" using assms ..
thus "q" ..
qed
next
have "q ∧ r" using assms ..
thus "r" ..
qed

lemma ejercicio_16c:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q)∧ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)
------------------------------------------------------------------ *}
lemma ejercicio_17a:
assumes "(p∧ q) ∧ r"
shows "p ∧ (q∧ r)"
proof -
have 1: "r" using assms by (rule conjunct2)
have 2: "(p∧q)" using assms by (rule conjunct1)
have 3: "p" using 2 by (rule conjunct1)
have 4: "q" using 2 by (rule conjunct2)
have 5: "(q∧r)" using 4 1 by (rule conjI)
show "p∧(q∧r)" using 3 5 by (rule conjI)
qed

lemma ejercicio_17b:
assumes "(p∧ q) ∧ r"
shows "p ∧ (q∧ r)"
proof (rule conjI)
have "p ∧ q" using assms ..
thus "p" ..
next
show "q ∧ r"
proof (rule conjI)
have "p ∧ q" using assms ..
thus "q" ..
next
show "r" using assms ..
qed
qed

lemma ejercicio_17c:
assumes "(p∧ q) ∧ r"
shows "p ∧ (q∧ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
p ∧ q ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_18a:
assumes "p ∧ q"
shows "p ⟶ q"
proof -
have 1: "q" using assms by (rule conjunct2)
show "p⟶ q" using 1 by (rule impI)
qed

lemma ejercicio_18b:
assumes "p ∧ q"
shows "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using assms ..
qed

lemma ejercicio_18c:
assumes "p ∧ q"
shows "p ⟶ q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 19. Demostrar
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r
------------------------------------------------------------------ *}

lemma ejercicio_19a:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof (rule impI)
assume "p"
show "q ∧ r"
proof (rule conjI)
have "p ⟶ q" using assms ..
thus "q" using `p` ..
have "p ⟶ r" using assms ..
thus "r" using `p` ..
qed
qed

lemma ejercicio_19c:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 20. Demostrar
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_20a:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof (rule conjI)
show "p ⟶ q"
proof (rule impI)
assume "p"
with `p ⟶ q ∧ r` have "q ∧ r" ..
thus "q" ..
qed
show "p ⟶ r"
proof (rule impI)
assume "p"
with `p ⟶ q ∧ r` have "q ∧ r" ..
thus "r" ..
qed
qed

lemma ejercicio_20c:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_21a:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
using assms by auto

lemma ejercicio_21b:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume "p ∧ q"
hence "p" ..
with `p ⟶ (q ⟶ r)` have "q ⟶ r" ..
have "q" using `p ∧ q` ..
with `q ⟶ r` show "r" ..
qed

lemma ejercicio_21c:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume "p ∧ q"
hence "p" ..
have "q" using `p ∧ q`..
have "q ⟶ r" using assms(1) `p` ..
thus "r" using `q` ..
qed

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_22a:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume "p"
show "q ⟶ r"
proof (rule impI)
assume "q"
with `p` have "p ∧ q" ..
with assms(1) show "r" ..
qed
qed

lemma ejercicio_22c:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_23a:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume "p ∧ q"
hence "q" ..
have "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using `q` .
qed
with assms(1) show "r" ..
qed

lemma ejercicio_23c:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 24. Demostrar
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_24b:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof (rule impI)
assume "p ⟶ q"
have "p" using assms(1) ..
with `p ⟶ q` have "q" ..
have "q ⟶ r" using assms(1) ..
thus "r" using `q` ..
qed

lemma ejercicio_24c:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
using assms by auto

section {* Disyunciones *}

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
p ⊢ p ∨ q
------------------------------------------------------------------ *}
lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
proof -
show "p∨q" using assms by (rule disjI1)
qed

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
q ⊢ p ∨ q
------------------------------------------------------------------ *}
lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
proof -
show "p∨q" using assms by (rule disjI2)
qed

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar
p ∨ q ⊢ q ∨ p
------------------------------------------------------------------ *}
lemma ejercicio_27a:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms by this
moreover
{ assume 2: "p"
have "q ∨ p" using 2 by (rule disjI2) }
moreover
{ assume 3: "q"
have "q ∨ p" using 3 by (rule disjI1) }
ultimately show "q ∨ p" by (rule disjE)
qed

lemma ejercicio_27b:
assumes "p ∨ q"
shows "q ∨ p"
proof -
note `p ∨ q`
moreover
{ assume "p"
hence "q ∨ p" ..}
moreover
{ assume "q"
hence "q ∨ p" .. }
ultimately show "q ∨ p" ..
qed

lemma ejercicio_27c:
assumes "p ∨ q"
shows "q ∨ p"
using assms
proof (rule disjE)
assume "p"
thus "q ∨ p" ..
next
assume "q"
thus "q ∨ p" ..
qed

lemma ejercicio_27d:
assumes "p ∨ q"
shows "q ∨ p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
------------------------------------------------------------------ *}

lemma ejercicio_28b:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume "p ∨ q"
show "p ∨ r"
using `p ∨ q`
proof (rule disjE)
assume "p"
thus "p ∨ r" ..
next
assume "q"
with assms(1) have "r" ..
thus "p ∨ r" ..
qed
qed

lemma ejercicio_28c:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 29. Demostrar
p ∨ p ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_29b:
assumes "p ∨ p"
shows "p"
using assms
proof (rule disjE)
assume "p"
thus "p" .
next
assume "p"
thus "p" .
qed

lemma ejercicio_29c:
assumes "p ∨ p"
shows "p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar
p ⊢ p ∨ p
------------------------------------------------------------------ *}

lemma ejercicio_30a:
assumes "p"
shows "p ∨ p"
using assms
proof (rule disjI1)
qed

lemma ejercicio_30b:
assumes "p"
shows "p ∨ p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r
------------------------------------------------------------------ *}

lemma ejercicio_31a:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
using assms
proof (rule disjE)
assume "p"
hence "p ∨ q" by (rule disjI1)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "q ∨ r"
thus "(p ∨ q) ∨ r"
proof (rule disjE)
assume "q"
hence "p ∨ q" by (rule disjI2)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "r"
thus "(p ∨ q) ∨ r" by (rule disjI2)
qed
qed

lemma ejercicio_31b:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_32:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 33. Demostrar
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)
------------------------------------------------------------------ *}

lemma ejercicio_33:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 34. Demostrar
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_34a:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms
proof
assume "p∧q"
show "p ∧ (q ∨ r)"
proof (rule conjI)
show "p" using `p∧q` ..
next
have "q" using `p∧q` ..
thus "q∨r" by (rule disjI1)
qed
next
assume "p∧r"
show "p ∧ (q ∨ r)"
proof (rule conjI)
show "p" using `p∧r` ..
next
have "r" using `p∧r` ..
thus "q∨r" by (rule disjI2)
qed
qed

lemma ejercicio_34b:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 35. Demostrar
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)
------------------------------------------------------------------ *}

lemma ejercicio_36a:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have "p ∨ q" using assms ..
thus "p ∨ (q ∧ r)"
proof
assume "p"
thus "p ∨ (q ∧ r)" by (rule disjI1)
next
assume "q"
have "p ∨ r" using assms ..
thus "p ∨ (q ∧ r)"
proof
assume "p"
thus "p ∨ (q∧r)" by (rule disjI1)
next
assume "r"
with `q` have "q ∧ r" ..
thus "p ∨ (q ∧ r)" by (rule disjI2)
qed
qed
qed

lemma ejercicio_36b:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_37:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof (rule impI)
assume "p ∨ q"
thus "r"
proof
assume "p"
have "p ⟶ r" using assms by (rule conjunct1)
thus "r" using `p` ..
next
assume "q"
have "q ⟶ r" using assms by (rule conjunct2)
thus "r" using `q` ..
qed
qed

lemma ejercicio_37b:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 38. Demostrar
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_38a:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof (rule conjI)
show "p ⟶ r"
proof (rule impI)
assume "p"
hence "p ∨ q" ..
with assms show "r" by (rule mp)
qed
next
show "q ⟶ r"
proof (rule impI)
assume "q"
hence "p ∨ q" ..
with assms show "r" by (rule mp)
qed
qed

lemma ejercicio_38b:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
using assms by auto

section {* Negaciones *}

text {* ---------------------------------------------------------------
Ejercicio 39. Demostrar
p ⊢ ¬¬p
------------------------------------------------------------------ *}
lemma ejercicio_39:
assumes "p"
shows "¬¬p"
proof -
show "¬¬p" using assms by (rule notnotI)
qed

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_40a:
assumes "¬p"
shows "p ⟶ q"
proof
assume "p"
with assms show "q" by (rule notE)
qed

lemma ejercicio_40b:
assumes "¬p"
shows "p ⟶ q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 41. Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
------------------------------------------------------------------ *}

lemma ejercicio_41:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with assms show "¬p" by (rule mt)
qed

lemma ejercicio_41b:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p∨q, ¬q ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_42a:
assumes "p∨q"
"¬q"
shows "p"
using assms(1)
proof
assume "p" thus "p" .
next
assume "q"
with assms(2) show "p" by (rule notE)
qed

lemma ejercicio_42b:
assumes "p∨q"
"¬q"
shows "p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p ∨ q, ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_43a:
assumes "p ∨ q"
"¬p"
shows "q"
using assms(1)
proof
assume "p"
with assms(2) show "q" by (rule notE)
next
assume "q" thus q .
qed

lemma ejercicio_43b:
assumes "p ∨ q"
"¬p"
shows "q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
p ∨ q ⊢ ¬(¬p ∧ ¬q)
------------------------------------------------------------------ *}

lemma ejercicio_44a:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
using assms
proof
assume "p"
show "¬(¬p ∧ ¬q)"
proof (rule notI)
assume "¬p ∧ ¬q"
hence "¬p" by (rule conjunct1)
thus False using `p` by (rule notE)
qed
next
assume "q"
show "¬(¬p ∧ ¬q)"
proof (rule notI)
assume "¬p ∧ ¬q"
hence "¬q" by (rule conjunct2)
thus False using `q` by (rule notE)
qed
qed

lemma ejercicio_44b:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof (rule notI)
assume "¬p ∧ ¬q"
show False using assms
proof (rule disjE)
assume "p"
have "¬p" using `¬p ∧ ¬q` by (rule conjunct1)
thus False using `p` by (rule notE)
next
assume "q"
have "¬q" using `¬p ∧ ¬q` by (rule conjunct2)
thus False using `q` by (rule notE)
qed
qed

lemma ejercicio_44c:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 45. Demostrar
p ∧ q ⊢ ¬(¬p ∨ ¬q)
------------------------------------------------------------------ *}

lemma ejercicio_45a:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
thus False
proof (rule disjE)
assume "¬p"
have "p" using assms ..
with `¬ p` show False ..
next
assume "¬q"
have "q" using assms by (rule conjunct2)
with `¬ q` show False by (rule notE)
qed
qed

lemma ejercicio_45c:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 46. Demostrar
¬(p ∨ q) ⊢ ¬p ∧ ¬q
------------------------------------------------------------------ *}

lemma ejercicio_46a:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof
assume "p"
hence "p ∨ q" by (rule disjI1)
with assms show False by (rule notE)
qed
next
show "¬q"
proof
assume "q"
hence "p ∨ q" ..
with assms show False ..
qed
qed

lemma ejercicio_46c:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 47. Demostrar
¬p ∧ ¬q ⊢ ¬(p ∨ q)
------------------------------------------------------------------ *}

lemma ejercicio_47a:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
thus False
proof
assume "p"
have "¬p" using assms by (rule conjunct1)
thus False using `p` by (rule notE)
next
assume "q"
have "¬q" using assms by (rule conjunct2)
thus False using `q` by (rule notE)
qed
qed

lemma ejercicio_47c:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 48. Demostrar
¬p ∨ ¬q ⊢ ¬(p ∧ q)
------------------------------------------------------------------ *}

lemma ejercicio_48a:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
using assms
proof
assume "¬p"
show "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
with `¬p` show False by (rule notE)
qed
next
assume "¬q"
show "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "q" ..
with `¬q` show False ..
qed
qed

lemma ejercicio_48b:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
show False
using assms
proof
assume "¬p"
have "p" using `p ∧ q` ..
with `¬p` show False ..
next
assume "¬q"
have "q" using `p ∧ q` ..
with `¬q` show False ..
qed
qed

lemma ejercicio_48c:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 49. Demostrar
⊢ ¬(p ∧ ¬p)
------------------------------------------------------------------ *}

lemma ejercicio_49a:
"¬(p ∧ ¬p)"
proof
assume "p ∧ ¬p"
hence "p" ..
have "¬ p" using `p ∧ ¬p` ..
thus False using `p` ..
qed

lemma ejercicio_49b:
"¬(p ∧ ¬p)"
by auto

text {* ---------------------------------------------------------------
Ejercicio 50. Demostrar
p ∧ ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_50:
assumes "p ∧ ¬p"
shows "q"
oops

text {* ---------------------------------------------------------------
Ejercicio 51. Demostrar
¬¬p ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_51a:
assumes "¬¬p"
shows "p"
using assms by (rule notnotD)

lemma ejercicio_51b:
assumes "¬¬p"
shows "p"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 52. Demostrar
⊢ p ∨ ¬p
------------------------------------------------------------------ *}

lemma ejercicio_52a:
"p ∨ ¬p"
proof -
have "¬¬p ∨ ¬p" ..
thus "p ∨ ¬p" by simp
qed

lemma ejercicio_52b:
"p ∨ ¬p"
proof -
have "¬p ∨ p" ..
thus "p ∨ ¬p" by (rule ejercicio_27a)
qed

lemma ejercicio_52c:
"p ∨ ¬p"
by auto

text {* ---------------------------------------------------------------
Ejercicio 53. Demostrar
⊢ ((p ⟶ q) ⟶ p) ⟶ p
------------------------------------------------------------------ *}

lemma ejercicio_53b:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume "(p ⟶ q) ⟶ p"
show "p"
proof (rule ccontr)
assume "¬p"
have "¬ (p ⟶ q)" using `(p ⟶ q) ⟶ p` `¬p` by (rule mt)
have "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using `¬p` `p` by (rule notE)
qed
show False using `¬ (p ⟶ q)` `p ⟶ q` ..
qed
qed

lemma ejercicio_53a:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume "(p ⟶ q) ⟶ p"
have "¬p ∨ p" by (rule excluded_middle)
thus "p"
proof (rule disjE)
{assume "¬p"
have "¬(p⟶ q)" using `(p ⟶ q) ⟶ p` `¬p` by (rule mt)
have "p⟶ q"
proof (rule impI)
assume "p"
show "q" using `¬p``p` by (rule notE)
qed
show "p" using `¬(p⟶ q)` `p⟶ q` by (rule notE)
}
next
{assume "p"
thus "p" .
}
qed
qed

lemma ejercicio_53c:
"((p ⟶ q) ⟶ p) ⟶ p"
by auto

text {* ---------------------------------------------------------------
Ejercicio 54. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_54:
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 55. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ejercicio_55a:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬p ∨ p" ..
thus "p∨q"
proof
assume "¬p"
have "¬q ∨ q" ..
thus "p∨q"
proof
assume "¬q"
with `¬p` have "¬p ∧ ¬q" by (rule conjI)
with assms show "p∨q" by (rule notE)
next
assume "q"
thus "p ∨ q" ..
qed
next
assume "p"
thus "p ∨q" ..
qed
qed

lemma ejercicio_55c:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 56. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ejercicio_56a:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
show "p"
proof -
have "¬p ∨ p" ..
thus "p"
proof
assume "¬p"
hence "¬p ∨ ¬q" by (rule disjI1)
with `¬(¬p ∨ ¬q)` show "p" by (rule notE)
next
assume "p" thus "p" .
qed
qed
next
show "q"
proof -
have "¬q ∨ q" ..
thus "q"
proof
assume "¬q"
hence "¬p ∨ ¬q" by (rule disjI2)
with `¬(¬p ∨ ¬q)` show "q" by (rule notE)
next
assume "q" thus "q" .
qed
qed
qed

lemma ejercicio_56c:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 57. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}

lemma ejercicio_57a:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨p" ..
thus "¬p ∨ ¬q"
proof
assume "¬p"
thus "¬p ∨ ¬q" ..
next
assume "p"
have "¬q ∨ q" ..
thus "¬p ∨ ¬q"
proof
assume "¬q"
thus "¬p ∨ ¬q" ..
next
assume "q"
with `p` have "p∧q" by (rule conjI)
with assms show "¬p ∨ ¬q" by (rule notE)
qed
qed
qed

lemma ejercicio_57c:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
using assms by auto

text {* ---------------------------------------------------------------
Ejercicio 58. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ejercicio_58a:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
assume "¬p"
show "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjI1)
show "p ⟶ q"
proof
assume "p"
with `¬ p` show "q" by (rule notE)
qed
qed
next
assume "p"
show "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjI2)
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using `p` .
qed
qed
qed
qed

lemma ejercicio_58b:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬p ∨ p" .. (* by (rule excluded_middle) *)
thus "(p ⟶ q) ∨ (q ⟶ p)"
proof
assume "¬p"
show "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjI1)
show "p ⟶ q"
proof
assume "p"
with `¬ p` show "q" .. (* by (rule notE) *)
qed
qed
next
assume "p"
show "(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjI2)
show "q ⟶ p"
proof (* (rule impI) *)
assume "q"
show "p" using `p` .
qed
qed
qed
qed

lemma ejercicio_58c:
"(p ⟶ q) ∨ (q ⟶ p)"
by auto

lemma ej_59: assumes "p ∧ ¬(q ⟶ r)"
shows "(p ∧ q) ∧ ¬r"
proof
show "p ∧ q"
proof
show "p" using assms by (rule conjunct1)
next
show "q"
proof (rule ccontr)
assume "¬q"
have "¬(q ⟶ r)" using assms ..
have "q ⟶ r"
proof
assume "q"
with `¬q` show "r" by (rule notE)
qed
with `¬(q ⟶ r)` show False ..
qed
qed
next
show "¬r"
proof
assume "r"
have "q ⟶ r"
proof
assume "q" show "r" using `r` .
qed
have "¬(q ⟶ r)" using assms ..
thus False using `q ⟶ r` ..
qed
qed

lemma ej_60: "¬(s ∨ (p ⟶ q)) ⟶ p ∧ ¬q ∧ ¬s"
proof
assume 1:"¬(s ∨ (p ⟶ q))"
show "p ∧ ¬q ∧ ¬s"
proof
show "p"
proof (rule ccontr)
assume "¬p"
have "p ⟶q"
proof
assume "p" with `¬p` show "q" by (rule notE)
qed
hence "s ∨ (p ⟶ q)" ..
with 1 show False ..
qed
next
show "¬q ∧ ¬s"
proof
show "¬q"
proof
assume "q"
have "p ⟶ q"
proof
assume "p" show "q" using `q` by this
qed
hence "s ∨ (p ⟶ q)" ..
with 1 show False ..
qed
next
show "¬s"
proof
assume "s"
hence "s ∨ (p ⟶ q)" ..
with 1 show False ..
qed
qed
qed
qed

lemma ejercicio_70:
assumes "p ∧ q ⟶ r ∨ s"
"q ⟶ ¬s"
shows "p ⟶ ¬q ∨ r"
proof
assume "p"
show "¬q ∨ r"
proof-
have "¬q ∨ q" ..
thus "¬q ∨ r"
proof (rule disjE)
assume "¬q"
thus "¬q ∨ r" ..
next
assume "q"
with `p` have "p ∧ q" ..
with assms(1) have "r ∨ s" ..
thus "¬q ∨ r"
proof (rule disjE)
assume "r" thus "¬q ∨ r" ..
next
assume "s"
hence "¬¬s" by (rule notnotI)
with assms(2) have "¬q" by (rule mt)
thus "¬q ∨ r" ..
qed
qed

qed
qed

lemma ejercicio_71:
assumes "∀x. (P(x) ⟶ Q(x))"
"∀x. (¬S(x) ⟶ ¬Q(x))"
"¬ (∀x. S(x))"
shows "∃x. ¬P(x)"
proof (rule ccontr)
assume 3: "¬ (∃x. ¬ P x)"
have "∀x. S(x)"
proof
fix a
show "S(a)"
proof (rule ccontr)
assume 1:"¬ S a"
have "¬S(a) ⟶ ¬Q(a)" using assms(2) by (rule allE)
hence 2:"¬Q(a)" using 1 ..
have "P(a) ⟶ Q(a)" using assms(1) ..
hence "¬P(a)" using 2 by (rule mt)
hence "∃x. ¬P(x)" ..
with 3 show False ..
qed
qed
with assms(3) show False ..
qed

end

</source>

Sol 4

2019-04-09T10:50:03Z

Mjoseh:

Ejercicios

2019-04-09T10:49:01Z

Mjoseh:

R8

2019-04-03T18:04:46Z

Mjoseh:

<source lang = "isabelle">
chapter {* R8: Argumentación en lógica de primer orden *}

theory R8
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es formalizar en lógica de primer orden
argumentos expresados en lenguaje natural.

Antes de escribir la soluciones, comprobar con APLI2 la corrección de la formalización.

Una vez formalizadas, probar que el razonamiento es correcto, o refutarlo mediante un contraejemplo.

Las demostraciones pueden hacerse usando Isar o tácticas de prueba.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar el 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
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar el siguiente argumento
Todos los participantes son vencedores. Hay como máximo un
vencedor. Hay como máximo un participante. Por lo tanto, hay
exactamente un participante.
Usar P(x) para x es un participante
V(x) para x es un vencedor
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar el siguiente argumento
Ningún aristócrata debe ser condenado a galeras a menos que sus
crímenes sean vergonzosos y lleve una vida licenciosa. En la ciudad
hay aristócratas que han cometido crímenes vergonzosos aunque su
forma de vida no sea licenciosa. Por tanto, hay algún aristócrata
que no está condenado a galeras.
Usar A(x) para x es aristócrata
G(x) para x está condenado a galeras
L(x) para x lleva una vida licenciosa
V(x) para x ha cometido crímenes vergonzoso
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar el siguiente argumento
Todos los robots obedecen a los amigos del programador jefe.
Alvaro es amigo del programador jefe, pero Benito no le
obedece. Por tanto, Benito no es un robot.
Usar R(x) para x es un robot
Ob(x,y) para x obedece a y
A(x) para x es amigo del programador jefe
b para Benito
a para Alvaro
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 5. Formalizar el siguiente argumento
Ningún socio del club está en deuda con el tesorero del club. Si
un socio del club no paga su cuota está en deuda con el tesorero
del club. Por tanto, si el tesorero del club es socio del club,
entonces paga su cuota.
Usar P(x) para x es socio del club
Q(x) para x paga su cuota
R(x) para x está en deuda con el tesorero
a para el tesorero del club
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 6. Formalizar el 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
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 7. Formalizar el siguiente argumento
Todo aquel que entre en el país y no sea un VIP será cacheado por
un aduanero. Hay un contrabandista que entra en el país y que solo
podrá ser cacheado por contrabandistas. Ningún contrabandista es un
VIP. Por tanto, algún aduanero es contrabandista.
Usar A(x) para x es aduanero
Ca(x,y) para x cachea a y
Co(x) para x es contrabandista
E(x) para x entra en el pais
V(x) para x es un VIP
------------------------------------------------------------------ *}

section {* Ejercicios con igualdad *}

text {* ---------------------------------------------------------------
Ejercicio 8. Formalizar el siguiente argumento
Rosa ama a Curro. Paco no simpatiza con Ana. Quien no simpatiza con
Ana ama a Rosa. Si una persona ama a otra, la segunda ama a la
primera. Hay como máximo una persona que ama a Rosa. Por tanto,
Paco es Curro.
Usar A(x,y) para x ama a y
S(x,y) para x simpatiza con y
a para Ana
c para Curro
p para Paco
r para Rosa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 9. Formalizar el siguiente argumento
Todos los filósofos se han preguntado qué es la filosofía. Los que
se preguntan qué es la filosofía se vuelven locos. Nietzsche es
filósofo. El maestro de Nietzsche no acabó loco. Por tanto,
Nietzsche y su maestro son diferentes personas.
Usar F(x) para x es filósofo
L(x) para x se vuelve loco
P(x) para x se ha preguntado qué es la filosofía.
m para el maestro de Nietzsche
n para Nietzsche
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 10. Formalizar el siguiente argumento
Eduardo pudo haber visto al asesino. Antonio fue el primer testigo
de la defensa. O Eduardo estaba en clase o Antonio dio falso
testimonio. Nadie en clase pudo haber visto al asesino. Luego, el
primer testigo de la defensa dio falso testimonio.
Usar C(x) para x estaba en clase
F(x) para x dio falso testimonio
V(x) para x pudo haber visto al asesino
a para Antonio
e para Eduardo
p para el primer testigo de la defensa
------------------------------------------------------------------ *}

end

</source>

R8

2019-04-03T18:04:33Z

Mjoseh:

Ejercicios

2019-04-03T18:02:34Z

Mjoseh:

R7

2019-03-28T12:29:39Z

Mjoseh:

<source lang = "isabelle">
theory R7
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es escribir demostraciones usando sólo
las reglas básicas de deducción natural de la lógica proposicional y
los métodos rule, erule, frule, drule y assumption.

Las reglas básicas de la deducción natural son las siguientes:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· conjE: ⟦P ∧ Q; ⟦P; Q⟧ ⟹ R⟧ ⟹ R
· notE: ⟦¬P; P⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· impE: ⟦P ⟶ Q; P; Q ⟹ R⟧ ⟹ R
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· FalseE: False ⟹ P
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· iffE: ⟦P = Q; ⟦P ⟶ Q; Q ⟶ P⟧ ⟹ R⟧ ⟹ R
· notnotD: ¬¬ P ⟹ P
· not_not: P = ¬¬P
· ccontr: (¬P ⟹ False) ⟹ P
· excluded_midle: ¬P ∨ P
· classical: (¬ P ⟹ P) ⟹ P
· contrapos_nn ⟦¬Q; P ⟹ Q⟧ ⟹ ¬P
---------------------------------------------------------------------
*}

section {* Implicaciones *}

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
p ⟶ q, p ⊢ q
------------------------------------------------------------------ *}

lemma ej1: "⟦p ⟶ q; p⟧ ⟹ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
p ⟶ q, q ⟶ r, p ⊢ r
------------------------------------------------------------------ *}

lemma ej2: "⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r
------------------------------------------------------------------ *}

lemma ej3a: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
oops

lemma ej3b: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
p ⟶ q, q ⟶ r ⊢ p ⟶ r
------------------------------------------------------------------ *}

-- "La demostración detallada es"
lemma ej4: "⟦p ⟶ q; q ⟶ r⟧ ⟹ p ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej5: "p ⟶ (q ⟶ r) ⟹ q ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej6: "p ⟶ (q ⟶ r) ⟹ (p ⟶ q) ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
p ⊢ q ⟶ p
------------------------------------------------------------------ *}

lemma ej7: "p ⟹ q ⟶ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
⊢ p ⟶ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ej8: "p ⟶ (q ⟶ p)"
oops

text {* ---------------------------------------------------------------
Ejercicio 9. Demostrar
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej9: "p ⟶ q ⟹ (q ⟶ r) ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))
------------------------------------------------------------------ *}

lemma ej10: "p ⟶ (q ⟶ (r ⟶ s)) ⟹ r ⟶ (q ⟶ (p ⟶ s))"
oops

text {* ---------------------------------------------------------------
Ejercicio 11. Demostrar
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))
------------------------------------------------------------------ *}

lemma ej11: "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
oops

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej12: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
oops

section {* Conjunciones *}

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
p, q ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ej13: "⟦p; q⟧ ⟹ p ∧ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
p ∧ q ⊢ p
------------------------------------------------------------------ *}

lemma ej14: "p ∧ q ⟹ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
p ∧ q ⊢ q
------------------------------------------------------------------ *}

lemma ej15: "p ∧ q ⟹ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r
------------------------------------------------------------------ *}

lemma ej16: "p ∧ (q ∧ r) ⟹ (p ∧ q) ∧ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)
------------------------------------------------------------------ *}

lemma ej17: "(p ∧ q) ∧ r ⟹ p ∧ (q ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
p ∧ q ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej18: "p ∧ q ⟹ p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 19. Demostrar
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r
------------------------------------------------------------------ *}

lemma ej19: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 20. Demostrar
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ej20: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ej21_1: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej22: "p ∧ q ⟶ r ⟹ p ⟶ (q ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ej23: "(p ⟶ q) ⟶ r ⟹ p ∧ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 24. Demostrar
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r
------------------------------------------------------------------ *}

lemma ej24: "p ∧ (q ⟶ r) ⟹ (p ⟶ q) ⟶ r"
oops

section {* Disyunciones *}

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
p ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej25: "p ⟹ p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
q ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej26: "q ⟹ p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar
p ∨ q ⊢ q ∨ p
------------------------------------------------------------------ *}

lemma ej27: "p ∨ q ⟹ q ∨ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
------------------------------------------------------------------ *}

lemma ej28: "q ⟶ r ⟹ p ∨ q ⟶ p ∨ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 29. Demostrar
p ∨ p ⊢ p
------------------------------------------------------------------ *}

lemma ej29: "p ∨ p ⟹ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar
p ⊢ p ∨ p
------------------------------------------------------------------ *}

lemma ej30: "p ⟹ p ∨ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r
------------------------------------------------------------------ *}

lemma ej31: "p ∨ (q ∨ r) ⟹ (p ∨ q) ∨ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)
------------------------------------------------------------------ *}

lemma ej32: "(p ∨ q) ∨ r ⟹ p ∨ (q ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 33. Demostrar
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)
------------------------------------------------------------------ *}

lemma ej33: "p ∧ (q ∨ r) ⟹ (p ∧ q) ∨ (p ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 34. Demostrar
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)
------------------------------------------------------------------ *}

lemma ej34: "(p ∧ q) ∨ (p ∧ r) ⟹ p ∧ (q ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 35. Demostrar
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)
------------------------------------------------------------------ *}

lemma ej35: "p ∨ (q ∧ r) ⟹ (p ∨ q) ∧ (p ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)
------------------------------------------------------------------ *}

lemma ej36: "(p ∨ q) ∧ (p ∨ r) ⟹ p ∨ (q ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r
------------------------------------------------------------------ *}

lemma ej37: "(p ⟶ r) ∧ (q ⟶ r) ⟹ p ∨ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 38. Demostrar
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ej38: "p ∨ q ⟶ r ⟹ (p ⟶ r) ∧ (q ⟶ r)"
oops

section {* Negación *}

text {* ---------------------------------------------------------------
Ejercicio 39. Demostrar
p ⊢ ¬¬p
------------------------------------------------------------------ *}

lemma ej39: "p ⟹ ¬¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej40: "¬p ⟹ p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 41. Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
------------------------------------------------------------------ *}

lemma ej41: "p ⟶ q ⟹ ¬q ⟶ ¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p ∨ q, ¬q ⊢ p
------------------------------------------------------------------ *}

lemma ej42: "⟦p ∨ q; ¬q⟧ ⟹ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 43. Demostrar
p ∨ q, ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ej43: "⟦p ∨ q; ¬p⟧ ⟹ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 44. Demostrar
p ∨ q ⊢ ¬(¬p ∧ ¬q)
------------------------------------------------------------------ *}

lemma ej44: "p ∨ q ⟹ ¬(¬p ∧ ¬q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 45. Demostrar
p ∧ q ⊢ ¬(¬p ∨ ¬q)
------------------------------------------------------------------ *}

lemma ej45: "p ∧ q ⟹ ¬(¬p ∨ ¬q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 46. Demostrar
¬(p ∨ q) ⊢ ¬p ∧ ¬q
------------------------------------------------------------------ *}

lemma ej46: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
oops

text {* ---------------------------------------------------------------
Ejercicio 47. Demostrar
¬p ∧ ¬q ⊢ ¬(p ∨ q)
------------------------------------------------------------------ *}

lemma ej47: "¬p ∧ ¬q ⟹ ¬(p ∨ q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 48. Demostrar
¬p ∨ ¬q ⊢ ¬(p ∧ q)
------------------------------------------------------------------ *}

lemma ej48: "¬p ∨ ¬q ⟹ ¬(p ∧ q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 49. Demostrar
⊢ ¬(p ∧ ¬p)
------------------------------------------------------------------ *}

lemma ej49: "¬(p ∧ ¬p)"
oops

text {* ---------------------------------------------------------------
Ejercicio 50. Demostrar
p ∧ ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ej50: "p ∧ ¬p ⟹ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 51. Demostrar
¬¬p ⊢ p
------------------------------------------------------------------ *}

lemma ej51: "¬¬p ⟹ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 52. Demostrar
⊢ p ∨ ¬p
------------------------------------------------------------------ *}

lemma ej52: "p ∨ ¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 53. Demostrar
⊢ ((p ⟶ q) ⟶ p) ⟶ p
------------------------------------------------------------------ *}

lemma ej53: "((p ⟶ q) ⟶ p) ⟶ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 54. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ej54: "¬q ⟶ ¬p ⟹ p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 55. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ej55: "¬(¬p ∧ ¬q) ⟹ p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 56. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ej56: "¬(¬p ∨ ¬q) ⟹ p ∧ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 57. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}

lemma ej57: "¬(p ∧ q) ⟹ ¬p ∨ ¬q"
oops

text {* ---------------------------------------------------------------
Ejercicio 58. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ej58: "(p ⟶ q) ∨ (q ⟶ p)"
oops

end

</source>

R7

2019-03-28T11:07:02Z

Mjoseh:

<source lang = "isabelle">
chapter {* R4: Deducción natural proposicional con tácticas *}

theory R7
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es escribir demostraciones usando sólo
las reglas básicas de deducción natural de la lógica proposicional y
los métodos rule, erule, frule, drule y assumption.

Las reglas básicas de la deducción natural son las siguientes:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬ P ⟹ P
· notnotI: P ⟹ ¬¬ P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
· 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
---------------------------------------------------------------------
*}

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

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

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

section {* Implicaciones *}

text {* ---------------------------------------------------------------
Ejercicio 1. Demostrar
p ⟶ q, p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_1:
assumes "p ⟶ q"
"p"
shows "q"
oops

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
p ⟶ q, q ⟶ r, p ⊢ r
------------------------------------------------------------------ *}

lemma ejercicio_2:
assumes "p ⟶ q"
"q ⟶ r"
"p"
shows "r"
oops

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r
------------------------------------------------------------------ *}

lemma ejercicio_3:
assumes "p ⟶ (q ⟶ r)"
"p ⟶ q"
"p"
shows "r"
oops

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
p ⟶ q, q ⟶ r ⊢ p ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_4:
assumes "p ⟶ q"
"q ⟶ r"
shows "p ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_5:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_6:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
p ⊢ q ⟶ p
------------------------------------------------------------------ *}

lemma ejercicio_7:
assumes "p"
shows "q ⟶ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
⊢ p ⟶ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ejercicio_8:
"p ⟶ (q ⟶ p)"
oops

text {* ---------------------------------------------------------------
Ejercicio 9. Demostrar
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_9:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))
------------------------------------------------------------------ *}

lemma ejercicio_10:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
oops

text {* ---------------------------------------------------------------
Ejercicio 11. Demostrar
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))
------------------------------------------------------------------ *}

lemma ejercicio_11:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
oops

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_12:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
oops

section {* Conjunciones *}

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
p, q ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ejercicio_13:
assumes "p"
"q"
shows "p ∧ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
p ∧ q ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
oops

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
p ∧ q ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
oops

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r
------------------------------------------------------------------ *}

lemma ejercicio_16:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)
------------------------------------------------------------------ *}

lemma ejercicio_17:
assumes "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
p ∧ q ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_18:
assumes "p ∧ q"
shows "p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 19. Demostrar
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r
------------------------------------------------------------------ *}

lemma ejercicio_19:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 20. Demostrar
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_20:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_21:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_22:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_23:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 24. Demostrar
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_24:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
oops

section {* Disyunciones *}

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
p ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
q ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar
p ∨ q ⊢ q ∨ p
------------------------------------------------------------------ *}

lemma ejercicio_27:
assumes "p ∨ q"
shows "q ∨ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
------------------------------------------------------------------ *}

lemma ejercicio_28:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 29. Demostrar
p ∨ p ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_29:
assumes "p ∨ p"
shows "p"
oops

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar
p ⊢ p ∨ p
------------------------------------------------------------------ *}

lemma ejercicio_30:
assumes "p"
shows "p ∨ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r
------------------------------------------------------------------ *}

lemma ejercicio_31:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 32. Demostrar
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_32:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 33. Demostrar
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)
------------------------------------------------------------------ *}

lemma ejercicio_33:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 34. Demostrar
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_34:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 35. Demostrar
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)
------------------------------------------------------------------ *}

lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)
------------------------------------------------------------------ *}

lemma ejercicio_36:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
oops

text {* ---------------------------------------------------------------
Ejercicio 37. Demostrar
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r
------------------------------------------------------------------ *}

lemma ejercicio_37:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
oops

text {* ---------------------------------------------------------------
Ejercicio 38. Demostrar
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)
------------------------------------------------------------------ *}

lemma ejercicio_38:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
oops

section {* Negaciones *}

text {* ---------------------------------------------------------------
Ejercicio 39. Demostrar
p ⊢ ¬¬p
------------------------------------------------------------------ *}

lemma ejercicio_39:
assumes "p"
shows "¬¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_40:
assumes "¬p"
shows "p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 41. Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
------------------------------------------------------------------ *}

lemma ejercicio_41:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p∨q, ¬q ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_42:
assumes "p∨q"
"¬q"
shows "p"
oops

text {* ---------------------------------------------------------------
Ejercicio 42. Demostrar
p ∨ q, ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_43:
assumes "p ∨ q"
"¬p"
shows "q"
oops

text {* ---------------------------------------------------------------
Ejercicio 40. Demostrar
p ∨ q ⊢ ¬(¬p ∧ ¬q)
------------------------------------------------------------------ *}

lemma ejercicio_44:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 45. Demostrar
p ∧ q ⊢ ¬(¬p ∨ ¬q)
------------------------------------------------------------------ *}

lemma ejercicio_45:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 46. Demostrar
¬(p ∨ q) ⊢ ¬p ∧ ¬q
------------------------------------------------------------------ *}

lemma ejercicio_46:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
oops

text {* ---------------------------------------------------------------
Ejercicio 47. Demostrar
¬p ∧ ¬q ⊢ ¬(p ∨ q)
------------------------------------------------------------------ *}

lemma ejercicio_47:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 48. Demostrar
¬p ∨ ¬q ⊢ ¬(p ∧ q)
------------------------------------------------------------------ *}

lemma ejercicio_48:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
oops

text {* ---------------------------------------------------------------
Ejercicio 49. Demostrar
⊢ ¬(p ∧ ¬p)
------------------------------------------------------------------ *}

lemma ejercicio_49:
"¬(p ∧ ¬p)"
oops

text {* ---------------------------------------------------------------
Ejercicio 50. Demostrar
p ∧ ¬p ⊢ q
------------------------------------------------------------------ *}

lemma ejercicio_50:
assumes "p ∧ ¬p"
shows "q"
oops

text {* ---------------------------------------------------------------
Ejercicio 51. Demostrar
¬¬p ⊢ p
------------------------------------------------------------------ *}

lemma ejercicio_51:
assumes "¬¬p"
shows "p"
oops

text {* ---------------------------------------------------------------
Ejercicio 52. Demostrar
⊢ p ∨ ¬p
------------------------------------------------------------------ *}

lemma ejercicio_52:
"p ∨ ¬p"
oops

text {* ---------------------------------------------------------------
Ejercicio 53. Demostrar
⊢ ((p ⟶ q) ⟶ p) ⟶ p
------------------------------------------------------------------ *}

lemma ejercicio_53:
"((p ⟶ q) ⟶ p) ⟶ p"
oops

text {* ---------------------------------------------------------------
Ejercicio 54. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}

lemma ejercicio_54:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 55. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}

lemma ejercicio_55:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 56. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}

lemma ejercicio_56:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
oops

text {* ---------------------------------------------------------------
Ejercicio 57. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}

lemma ejercicio_57:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
oops

text {* ---------------------------------------------------------------
Ejercicio 58. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}

lemma ejercicio_58:
"(p ⟶ q) ∨ (q ⟶ p)"
oops

end

</source>

R7

2019-03-28T11:06:51Z

Mjoseh: