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

Definiciones inductivas

2020-05-27T18:21:51Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 9: Definiciones inductivas›

theory T9_Definiciones_inductivas
imports Main
begin

section ‹El conjunto de los números pares›

text ‹
· El conjunto de los números pares se define inductivamente como el
menor conjunto que contiene al 0 y es cerrado por la operación (+2).

· El conjunto de los números pares también puede definirse como los
naturales divisible por 2.

· Veremos cómo se escriben las dos definiciones en Isabelle/HOL y cómo
se demuestra su equivalencia.›

subsection ‹Definición inductiva del conjunto de los pares›

inductive_set par :: "nat set" where
cero [intro!]: "0 ∈ par"
| paso [intro!]: "n ∈ par ⟹ (Suc (Suc n)) ∈ par"

text ‹
· Una definición inductiva está formada con reglas de introducción.

· La definición inductiva genera varios teoremas:
· par.cero: 0 ∈ par
· par.paso: n ∈ par ⟹ Suc (Suc n) ∈ par
· par.simps: (a ∈ par) = (a = 0 ∨ (∃n. a = Suc (Suc n) ∧ n ∈ par))
›

thm par.cero
thm par.paso
thm par.simps

subsection ‹Uso de las reglas de introducción›

text ‹
Lema: Los números de la forma 2*k son pares.
›

― ‹La demostración aplicativa es›
lemma dobles_son_pares [intro!]:
"2*k ∈ par"
apply (induct k)
(* 1. 2 * 0 ∈ par
2. ⋀k. 2 * k ∈ par ⟹ 2 * Suc k ∈ par *)
apply simp_all
(* *)
done

― ‹La demostración automática es›
lemma dobles_son_pares_2:
"2*k ∈ par"
by (induct k) auto

― ‹La demostración estructurada es›
lemma dobles_son_pares_3:
"2*k ∈ par"
proof (induct k)
show "2 * 0 ∈ par"
by auto
next
show "⋀k. 2 * k ∈ par ⟹ 2 * Suc k ∈ par"
by auto
qed

text ‹
· Nota: Nuestro objetivo es demostrar la equivalencia de la definición
anterior y la definición mediante divisibilidad (even).

· Lema: Si n es divisible por 2, entonces es par.
›

lemma even_imp_par: "even n ⟹ n ∈ par"
using dobles_son_pares_3 by blast

subsection ‹Regla de inducción›

text ‹Entre las reglas generadas por la definión de par está la de
inducción:
· par.induct: ⟦ x ∈ par;
P 0;
⋀n. ⟦n ∈ par; P n⟧ ⟹ P (Suc (Suc n))⟧
⟹ P x
›

thm par.induct

text ‹Lema: Los números pares son divisibles por 2.›

― ‹Demostración aplicativa›
lemma par_imp_even:
"n ∈ par ⟹ even n"
apply (induction rule: par.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (simp only: dvd_def)
(* 1. ∃k. 0 = 2 * k
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (rule_tac x=0 in exI)
(* 1. 0 = 2 * 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply simp
(* ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (simp only: dvd_def)
(* ⋀n. ⟦n ∈ par; ∃k. n = 2 * k⟧ ⟹ ∃k. Suc (Suc n) = 2 * k *)
apply (erule exE)
(* ⋀n k. ⟦n ∈ par; n = 2 * k⟧ ⟹ ∃k. Suc (Suc n) = 2 * k*)
apply (rule_tac x="k+1" in exI)
(* ⋀n k. ⟦n ∈ par; n = 2 * k⟧ ⟹ Suc (Suc n) = 2 * (k + 1) *)
apply simp
(* *)
done

― ‹2ª demostración aplicativa›
lemma par_imp_even_2:
"n ∈ par ⟹ even n"
apply (induction rule: par.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply simp_all
(* *)
done

― ‹Demostración automática›
lemma par_imp_even_3:
"n ∈ par ⟹ even n"
by (induction rule: par.induct) simp_all

― ‹Demostración declarativa›
lemma par_imp_even_4:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "even 0"
by simp
next
fix n :: nat
assume H1: "n ∈ par" and
H2: "even n"
have "∃k. n = 2*k"
using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k"
by (rule exE)
then have "Suc (Suc n) = 2*(k+1)"
by simp
then have "∃k. Suc (Suc n) = 2*k"
by (rule exI)
then show "even (Suc (Suc n))"
by (simp add: dvd_def)
qed

― ‹2ª demostración declarativa›
lemma par_imp_even_5:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "even 0" by simp
next
fix n::nat
assume H1: "n ∈ par" and
H2: "even n"
then show "even (Suc (Suc n))"
by simp
qed

text ‹Lema: Un número n es par syss es divisible por 2.›

theorem par_iff_even: "(n ∈ par) = (even n)"
using even_imp_par par_imp_even_5 by blast

subsection ‹Generalización y regla de inducción›

text ‹
· Antes de aplicar inducción se debe de generalizar la fórmula a
probar.

· Vamos a ilustrar el principio anterior en el caso de los conjuntos
inductivamente definidos, con el siguiente ejemplo: si n+2 es par,
entonces n también lo es.

· El siguiente intento falla:
›

lemma "Suc (Suc n) ∈ par ⟹ n ∈ par"
apply (erule par.induct)
(* 1. n ∈ par
2. ⋀na. ⟦na ∈ par; n ∈ par⟧ ⟹ n ∈ par *)
oops

text ‹
En el intento anterior, los subobjetivos generados son
1. n ∈ par
2. ⋀na. ⟦na ∈ par; n ∈ par⟧ ⟹ n ∈ par
que no se pueden demostrar.

Se ha perdido la información sobre Suc (Suc n).
›

text ‹Reformulación del lema: Si n es par, entonces n-2 también lo es.›

― ‹La demostración aplicativa es›
lemma par_imp_par_menos:
"n ∈ par ⟹ n - 2 ∈ par"
apply (induction rule: par.induct)
(* 1. 0 - 2 ∈ par
2. ⋀n. ⟦n ∈ par; n - 2 ∈ par⟧ ⟹ Suc (Suc n) - 2 ∈ par *)
apply auto
(* *)
done

― ‹La demostración automática es›
lemma par_imp_par_menos_2:
"n ∈ par ⟹ n - 2 ∈ par"
by (induction rule: par.induct) auto

― ‹La demostración estructurada es›
lemma "n ∈ par ⟹ n - 2 ∈ par"
proof (induction rule: par.induct)
show "0 - 2 ∈ par"
by auto
next
show "⋀n. ⟦n ∈ par; n - 2 ∈ par⟧ ⟹ Suc (Suc n) - 2 ∈ par"
by auto
qed

text ‹Con el lema anterior se puede demostrar el original.›

― ‹La demostración aplicativa es›
lemma
"Suc (Suc n) ∈ par ⟹ n ∈ par"
apply (drule par_imp_par_menos_2)
(* Suc (Suc n) - 2 ∈ par ⟹ n ∈ par *)
apply simp
(* *)
done

― ‹La demostración automática es›
lemma Suc_Suc_par_imp_par:
"Suc (Suc n) ∈ par ⟹ n ∈ par"
by (drule par_imp_par_menos_2, simp)

― ‹La demostración declarativa es›
lemma
assumes "Suc (Suc n) ∈ par"
shows "n ∈ par"
proof -
have "Suc (Suc n) - 2 ∈ par"
using assms by (rule par_imp_par_menos_2)
then show "n ∈ par"
by simp
qed

text ‹Lemma. Un número natural n es par syss n+2 es par.›

lemma [iff]: "((Suc (Suc n)) ∈ par) = (n ∈ par)"
using Suc_Suc_par_imp_par by blast

text ‹Se usa el atributo "iff" porque sirve como regla de
simplificación.›

subsection ‹Definiciones mutuamente inductivas›

text ‹Definición cruzada de los conjuntos inductivos de los pares y de los
impares:›

inductive_set
Pares :: "nat set" and
Impares :: "nat set"
where
ceroP: "0 ∈ Pares"
| ParesI: "n ∈ Impares ⟹ Suc n ∈ Pares"
| ImparesI: "n ∈ Pares ⟹ Suc n ∈ Impares"

text ‹El esquema de inducción generado por la definición anterior es
· Pares_Impares.induct:
⟦P1 0;
⋀n. ⟦n ∈ Impares; P2 n⟧ ⟹ P1 (Suc n);
⋀n. ⟦n ∈ Pares; P1 n⟧ ⟹ P2 (Suc n)⟧
⟹ (x1 ∈ Pares ⟶ P1 x1) ∧ (x2 ∈ Impares ⟶ P2 x2)
›

thm Pares_Impares.induct

text ‹Ejemplo de demostración usando el esquema anterior.›

― ‹Demostración aplicativa›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
apply (induction rule: Pares_Impares.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ Impares; even (Suc n)⟧ ⟹ even (Suc n)
3. ⋀n. ⟦n ∈ Pares; even n⟧ ⟹ even (Suc (Suc n))*)
apply auto
(* *)
done

― ‹Demostración automática›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
by (induction rule: Pares_Impares.induct) auto

― ‹La demostración declarativa es›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
proof (induction rule: Pares_Impares.induct)
show "even (0::nat)"
by simp
next
fix n :: "nat"
assume H1: "n ∈ Impares" and
H2: "even (Suc n)"
show "even (Suc n)"
using H2 by simp
next
fix n :: "nat"
assume H1: "n ∈ Pares" and
H2: "even n"
have "∃k. n = 2*k"
using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k"
by (rule exE)
then have "Suc (Suc n) = 2*(k+1)"
by auto
then have "∃k. Suc (Suc n) = 2*k"
by (rule exI)
then show "even (Suc (Suc n))"
by (simp add: dvd_def)
qed

subsection ‹Definición inductiva de predicados›

text ‹Definición inductiva del predicado es_par tal que (es_par n) se
verifica si n es par.›

inductive es_par :: "nat ⇒ bool" where
"es_par 0"
| "es_par n ⟹ es_par (Suc (Suc n))"

text ‹Heurística para elegir entre definir conjuntos o predicados:
· si se va a combinar con operaciones conjuntistas, definir conjunto;
· en caso contrario, definir predicado.›

end
</source>

Desarrollo de teorías formalizadas con Isabelle/HOL

2020-05-20T15:20:32Z

Jalonso:

<source lang="isabelle">
chapter ‹Desarrollo de teorías formalizadas›

theory T11_Desarrollo_de_teorias_formalizadas
imports Main
begin

section ‹Desarrollo de la teoría de grupos›

text ‹El objetivo de este tema es mostrar cómo se puede trabajar en
estructuras algebraicas por medio de locales.

Se usará como ejemplo la teoría de grupos.›

text ‹Ejemplo 1. Un grupo es una estructura (G,·,𝟭,^) tal que
* G es un conjunto,
* · es una operación binaria en G,
* 𝟭 es un elemento de G y
* ^ es una función de G en G
tales que se cumplen las siguientes propiedades:
* asociativa: ∀x y z. x ⋅ (y ⋅ z) = (x ⋅ y) ⋅ z
* neutro por la izquierda: ∀x. 𝟭 ⋅ x = x
* inverso por la izquierda: ∀x. x^ ⋅ x = 𝟭

Definir el entorno axiomático de los grupos.›

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and inverso_i: "x^ ⋅ x = 𝟭"

text ‹Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^.›

text ‹A continuación se crea un contexto en el que se supone la
notación y axiomas de grupos.

En el contexto se demuestran propiedades de los grupos.›

context grupo
begin

text ‹Ejemplo 2. En los grupos, x^ también es el inverso de x por la
derecha; es decir
x ⋅ x^ = 𝟭›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "x ⋅ x^ = 𝟭"
(* sledgehammer *)
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma inverso_d:
"x ⋅ x^ = 𝟭"
proof -
have "x ⋅ x^ = 𝟭 ⋅ (x ⋅ x^)"
by (simp only: neutro_i)
also have "… = (𝟭 ⋅ x) ⋅ x^"
by (simp only: asociativa)
also have "… = (((x^)^ ⋅ x^) ⋅ x) ⋅ x^"
by (simp only: inverso_i)
also have "… = ((x^)^ ⋅ (x^ ⋅ x)) ⋅ x^"
by (simp only: asociativa)
also have "… = ((x^)^ ⋅ 𝟭) ⋅ x^"
by (simp only: inverso_i)
also have "… = (x^)^ ⋅ (𝟭 ⋅ x^)"
by (simp only: asociativa)
also have "… = (x^)^ ⋅ x^"
by (simp only: neutro_i)
also have "… = 𝟭"
by (simp only: inverso_i)
finally show ?thesis
by this
qed

text ‹Ejemplo 2. En los grupos, 𝟭 también es el neutro por la derecha;
es decir
x ⋅ 𝟭 = x›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "x ⋅ 𝟭 = x"
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma neutro_d:
"x ⋅ 𝟭 = x"
proof -
have "x ⋅ 𝟭 = x ⋅ (x^ ⋅ x)"
by (simp only: inverso_i)
also have "… = (x ⋅ x^) ⋅ x"
by (simp only: asociativa)
also have "… = 𝟭 ⋅ x"
by (simp only: inverso_d)
also have "… = x"
by (simp only: neutro_i)
finally show "x ⋅ 𝟭 = x"
by this
qed

text ‹Ejemplo 3. En los grupos, se tiene la propiedad cancelativa por la
izquierda; es decir,
x ⋅ y = x ⋅ z syss y = z›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x ⋅ y = x ⋅ z) = (y = z)"
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma cancelativa_i:
"(x ⋅ y = x ⋅ z) = (y = z)"
proof
assume "x ⋅ y = x ⋅ z"
then have "x^ ⋅ (x ⋅ y) = x^ ⋅ (x ⋅ z)"
by (simp only: arg_cong [of "x ⋅ y" "x ⋅ z"])
then have "(x^ ⋅ x) ⋅ y = (x^ ⋅ x) ⋅ z"
by (simp only: asociativa)
then have "𝟭 ⋅ y = 𝟭 ⋅ z"
by (simp only: inverso_i)
thus "y = z"
by (simp only: neutro_i)
next
assume "y = z"
then show "x ⋅ y = x ⋅ z"
by (simp only: arg_cong [of "y" "z"])
qed

text ‹Ejemplo 4. En los grupos, el elemento neutro por la izquierda es
único; es decir, si e es un elemento tal que para todo x se tiene que
e ⋅ x = x, entonces e = 𝟭.›

― ‹La demostración automática es (obtenida con Sledgehammer) es›
lemma
assumes "e ⋅ x = x"
shows "𝟭 = e"
using assms
by (metis asociativa inverso_d neutro_d)

― ‹La demostración estructurada es›
lemma unicidad_neutro_i:
assumes "e ⋅ x = x"
shows "𝟭 = e"
proof -
have "𝟭 = x ⋅ x^"
by (simp only: inverso_d)
also have "... = (e ⋅ x) ⋅ x^"
using assms [THEN sym]
by (rule arg_cong [of "x" "e ⋅ x" "λy. y ⋅ x^"])
also have "... = e ⋅ (x ⋅ x^)"
by (simp only: asociativa)
also have "... = e ⋅ 𝟭"
by (simp only: inverso_d)
also have "... = e"
by (simp only: neutro_d)
finally show ?thesis
by this
qed

text ‹Ejemplo 5. En los grupos, los inversos por la izquierda son
únicos; es decir, si x' es un elemento tal que x' ⋅ x = 𝟭, entonces
x^ = x'.›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma
assumes "x' ⋅ x = 𝟭"
shows "x^ = x'"
using assms
by (metis asociativa inverso_i neutro_i)

― ‹La demostración estructurada es›
lemma unicidad_inverso_i:
assumes "x' ⋅ x = 𝟭"
shows "x^ = x'"
proof -
have "x^ = 𝟭 ⋅ x^"
by (simp only: neutro_i)
also have "... = (x' ⋅ x) ⋅ x^"
using assms [THEN sym]
by (simp only: arg_cong [of "𝟭" "x' ⋅ x"])
also have "... = x' ⋅ (x ⋅ x^)"
by (simp only: asociativa)
also have "... = x' ⋅ 𝟭"
by (simp only: inverso_d)
also have "... = x'"
by (simp only: neutro_d)
finally show ?thesis
by this
qed

text ‹Ejemplo 6. En los grupos, es inverso de un producto es el
producto de los inversos cambiados de orden; es decir,
(x ⋅ y)^ = y^ ⋅ x^›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x ⋅ y)^ = y^ ⋅ x^"
by (metis asociativa inverso_d neutro_d)

― ‹La demostración detallada es›
lemma inversa_producto:
"(x ⋅ y)^ = y^ ⋅ x^"
proof (rule unicidad_inverso_i)
show "(y^ ⋅ x^) ⋅ (x ⋅ y) = 𝟭"
proof -
have "(y^ ⋅ x^) ⋅ (x ⋅ y) = (y^ ⋅ (x^ ⋅ x)) ⋅ y"
by (simp only: asociativa)
also have "... = (y^ ⋅ 𝟭) ⋅ y"
by (simp only: inverso_i)
also have "... = y^ ⋅ y"
by (simp only: neutro_d)
also have "... = 𝟭"
by (simp only: inverso_i)
finally show ?thesis
by this
qed
qed

text ‹Ejemplo 7. En los grupos, el inverso del inverso es el propio
elemento; es decir,
(x^)^ = x›

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x^)^ = x"
using inverso_d unicidad_inverso_i by blast

― ‹La demostración estructurada es›
lemma inverso_inverso:
"(x^)^ = x"
proof (rule unicidad_inverso_i)
show "x ⋅ x^ = 𝟭"
by (simp only: inverso_d)
qed

text ‹Ejemplo 8. En los grupos, la función inversa es inyectiva; es
decir, si x e y tienen los mismos inversos, entonces son iguales.›

― ‹La demostración automática es (obtenida con Sledgehammer) es›
lemma
assumes "x^ = y^"
shows "x = y"
using assms
by (metis inverso_inverso)

― ‹La demostración automática estructurada es›
lemma inversa_inyectiva:
assumes "x^ = y^"
shows "x = y"
proof -
have "(x^)^ = (y^)^"
using assms by (simp only: arg_cong [of "x^" "y^"])
thus "x = y"
by (simp only: inverso_inverso)
qed

end

section ‹Teorías de órdenes mediante clases›

text ‹El tutorial sobre clases está en la teoría Clases.thy.

La clase de los órdenes es la colección de los tipos que poseen una
relación ≼ verificando las siguientes propiedades
· reflexiva: x ≼ x
· transitiva: ⟦x ≼ y; y ≼ z⟧ ⟹ x ≼ z
· antisimétrica: ⟦x ≼ y; y ≼ x⟧ ⟹ x = y
›

class orden =
fixes menor_ig :: "'a ⇒ 'a ⇒ bool" (infix "≼" 50)
assumes refl: "x ≼ x"
and trans: "⟦x ≼ y; y ≼ z⟧ ⟹ x ≼ z"
and antisim: "⟦x ≼ y; y ≼ x⟧ ⟹ x = y"

text ‹Ha generado los teoremas correspondientes a los axiomas. Pueden
consultarse mediante thm como se muestra a continuación.›

thm trans

text ‹Se inicia el contexto orden en el que se van a realizar
definiciones y demostraciones.›

context orden
begin

text ‹x es menor que y si x es menor o igual que y y no es menos o igual
que x.›

definition menor :: "'a ⇒ 'a ⇒ bool" (infix "≺" 50)
where "x ≺ y ⟷ x ≼ y ∧ ¬ y ≼ x"

text ‹La relación menor es irreflexiva.›

lemma irrefl: "¬ x ≺ x"
by (auto simp: menor_def)

text ‹La relación menor es transitiva.›

(* Demostración aplicativa *)
lemma "⟦x ≺ y; y ≺ z⟧ ⟹ x ≺ z"
apply (unfold menor_def)
(* ⟦x ≼ y ∧ ¬ y ≼ x; y ≼ z ∧ ¬ z ≼ y⟧ ⟹ x ≼ z ∧ ¬ z ≼ x *)
apply (auto intro: trans)
(* *)
done

(* Demostración automática *)
lemma menor_trans: "⟦x ≺ y; y ≺ z⟧ ⟹ x ≺ z"
by (auto simp: menor_def intro: trans)

text ‹La relación menor es asimétrica; es decir, si x ≺ y e y ≺ x,
entonces se verifica cualquier propiedad P. ›

lemma asimetrica: "x ≺ y ⟹ y ≺ x ⟹ P"
by (simp add: menor_def)

end

subsection ‹Subclase›

text ‹Un orden lineal es un orden en que cada par de elementos son
comparables.›

class ordenLineal = orden +
assumes lineal: "x ≼ y ∨ y ≼ x"
begin

text ‹En los órdenes lineales se tiene que x ≺ y ∨ x = y ∨ y ≺ x.›

(* Demostración aplicativa *)
lemma "x ≺ y ∨ x = y ∨ y ≺ x"
apply (unfold menor_def)
(* (x ≼ y ∧ ¬ y ≼ x) ∨ x = y ∨ (y ≼ x ∧ ¬ x ≼ y) *)
apply auto
(* 1. ⟦x ≠ y; ¬ x ≼ y⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (cut_tac x=x and y=y in lineal)
(* 1. ⟦x ≠ y; ¬ x ≼ y; x ≼ y ∨ y ≼ x⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (erule disjE)
(* 1. ⟦x ≠ y; ¬ x ≼ y; x ≼ y⟧ ⟹ y ≼ x
2. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
3. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (erule_tac P="x ≼ y" in notE)
(* 1. ⟦x ≠ y; x ≼ y⟧ ⟹ x ≼ y
2. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
3. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (drule antisim)
(* 1. ⟦x ≠ y; x ≼ y⟧ ⟹ x ≼ y
2. ⟦x ≠ y; x ≼ y; y = x⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; x ≼ y; y = x⟧ ⟹ False *)
apply (erule notE)
(* 1. ⟦x ≼ y; y = x⟧ ⟹ x = y *)
apply (erule sym)
(* *)
done

(* Demostración automática *)
lemma "x ≺ y ∨ x = y ∨ y ≺ x"
using antisim lineal menor_def by auto

end

section ‹Teoría de órdenes mediante ámbitos ("Locales")›

text ‹Un orden es una estructura con una relación reflexiva,
transitiva y antisimétrica.›

locale Orden =
fixes menor_ig :: "'a ⇒ 'a ⇒ bool" (infix "⊑" 50)
assumes refl: "x ⊑ x"
and trans: "⟦x ⊑ y; y ⊑ z⟧ ⟹ x ⊑ z"
and antisim: "⟦x ⊑ y; y ⊑ x⟧ ⟹ x = y"

text ‹Los teoremas se diferencian por el nombre y el ámbito.
Por ejemplo,
refl: ?x ≼ ?x
Orden.refl: Orden ?menor_ig ⟹ ?menor_ig ?x ?x
Orden_def: Orden ?menor_ig ≡
(∀x. ?menor_ig x x) ∧
(∀x y z. ?menor_ig x y ⟶ ?menor_ig y z ⟶ ?menor_ig x z) ∧
(∀x y. ?menor_ig x y ⟶ ?menor_ig y x ⟶ x = y)
›

thm refl
thm Orden.refl
thm Orden_def

text ‹Un orden lineal es un orden en el que todos los pares de elementos son
comparables.›

locale OrdenLineal = Orden +
assumes lineal: "x ⊑ y ∨ y ⊑ x"

text ‹Los boooleanos está ordenados con el condicional.›

interpretation Orden_imp: Orden "λx y. x ⟶ y"
proof
fix P show "P ⟶ P" by simp
next
fix P Q R show "P ⟶ Q ⟹ Q ⟶ R ⟹ P ⟶ R" by simp
next
fix P Q show "P ⟶ Q ⟹ Q ⟶ P ⟹ P = Q" by blast
qed

text ‹Los naturales con la relación de divisibilidad es un conjunto
ordenado.›

interpretation Orden_dvd: Orden "(dvd) :: nat ⇒ nat ⇒ bool"
proof
fix x :: nat
show "x dvd x" by simp
next
fix x y z :: nat
show "⟦x dvd y; y dvd z⟧ ⟹ x dvd z" by auto
next
fix x y :: nat
show "⟦x dvd y; y dvd x⟧ ⟹ x = y" by auto
qed

section ‹Semigrupos, monoides y grupos›

subsection ‹Definición de clases›

text ‹Un semigrupo es una estructura compuesta por un conjunto A y una
operación binaria en A.›

class semigrupo =
fixes mult :: "'a ⇒ 'a ⇒ 'a" (infixl "⊗" 70)
assumes asoc: "(x ⊗ y) ⊗ z = x ⊗ (y ⊗ z )"

subsection ‹Instanciación de clases›

text ‹Los enteros con la suma forman un semigrupo.›

instantiation int :: semigrupo
begin
definition
mult_int_def: "i ⊗ j = i + (j ::int)"

instance proof
fix i j k :: "int"
have "(i + j ) + k = i + (j + k)" by simp
then show "(i ⊗ j ) ⊗ k = i ⊗ (j ⊗ k)" unfolding mult_int_def .
qed
end

text ‹Los naturales con la suma forman un semigrupo.›

instantiation nat :: semigrupo
begin
fun mult_nat where
"(0::nat) ⊗ n = n"
| "Suc m ⊗ n = Suc (m ⊗ n)"

instance proof
fix m n q :: "nat"
show "m ⊗ n ⊗ q = m ⊗ (n ⊗ q)"
by (induct m) auto
qed
end

subsection ‹Instancias recursivas›

text ‹Si (A,⊗) y (B,⊗) son semigrupos, entonces ((A×B,⊗), donde el
producto se define por
(x,y)⊗(x',y') = (x⊗x',y⊗y'),
es un semigrupo.›

instantiation prod :: (semigrupo, semigrupo) semigrupo
begin

definition
mult_prod_def : "p1 ⊗ p2 = (fst p1 ⊗ fst p2, snd p1 ⊗ snd p2)"

instance proof
fix p1 p2 p3 :: "'a::semigrupo × 'b::semigrupo"
show "(p1 ⊗ p2) ⊗ p3 = p1 ⊗ (p2 ⊗ p3)"
unfolding mult_prod_def by (simp add: asoc)
qed
end

subsection ‹Subclases›

text ‹ Un monoide izquierdo es un semigrupo con elemento neutro por la
izquierda.›

class monoideI = semigrupo +
fixes neutro :: "'a" ("𝟭")
assumes neutroI: "𝟭 ⊗ x = x"

text ‹Los naturales y los enteros con la suma forman monoides por la
izquierda.›

instantiation nat and int :: monoideI
begin

definition
neutro_nat_def : "𝟭 = (0::nat)"

definition
neutro_int_def : "𝟭 = (0::int)"

instance proof
fix n :: nat
show "𝟭 ⊗ n = n" unfolding neutro_nat_def by simp
next
fix k :: int
show "𝟭 ⊗ k = k" unfolding neutro_int_def mult_int_def by simp
qed
end

text ‹El producto de dos monoides por la izquierda es un monoide por la
izquierda, donde el neutro es el par formado por los elementos
neutros.›

instantiation prod :: (monoideI , monoideI) monoideI
begin

definition
neutro_prod_def : "𝟭 = (𝟭, 𝟭)"

instance proof
fix p :: "'a::monoideI × 'b::monoideI"
show "𝟭 ⊗ p = p"
unfolding neutro_prod_def mult_prod_def by (simp add: neutroI)
qed
end

text ‹Un monoide es un monoide por la izquierda cuyo elemento neutro
por la izquierda lo es también por la derecha.›

class monoide = monoideI +
assumes neutro: "x ⊗ 𝟭 = x"

text ‹Los naturales y los enteros con la suma son monoides.›

instantiation nat and int :: monoide
begin

instance proof
fix n :: nat
show "n ⊗ 𝟭 = n"
unfolding neutro_nat_def by (induct n) simp_all
next
fix k :: int
show "k ⊗ 𝟭 = k"
unfolding neutro_int_def mult_int_def by simp
qed
end

text ‹El producto de dos monoides es un monoide.›

instantiation prod :: (monoide, monoide) monoide
begin

instance proof
fix p :: "'a::monoide × 'b::monoide"
show "p ⊗ 𝟭 = p"
unfolding neutro_prod_def mult_prod_def by (simp add: neutro)
qed
end

text ‹Un grupo es un monoide por la izquierda tal que todo elemento
posee un inverso por la izquierda.›

class grupo2 = monoideI +
fixes inverso :: "'a ⇒ 'a" ("(_⇧-⇧1)" [1000] 999)
assumes inversoI: "x⇧-⇧1 ⊗ x = 𝟭"

text ‹Los enteros con la suma forman un grupo.›

instantiation int :: grupo2
begin

definition
inverso_int_def: "i⇧-⇧1 = -(i::int)"

instance proof
fix i :: "int"
have "-i + i = 0" by simp
then show "i⇧-⇧1 ⊗ i = 𝟭"
unfolding mult_int_def neutro_int_def inverso_int_def .
qed
end

subsection ‹Razonamiento abstracto›

text ‹En los grupos se verifica la propiedad cancelativa por la
izquierda, i.e.
x ⊗ y = x ⊗ z ⟷ y = z
›

lemma (in grupo2) cancelativa_izq: "x ⊗ y = x ⊗ z ⟷ y = z"
proof
assume "x ⊗ y = x ⊗ z"
then have "x⇧-⇧1 ⊗ (x ⊗ y) = x⇧-⇧1 ⊗ (x ⊗ z)"
by simp
then have "(x⇧-⇧1 ⊗ x) ⊗ y = (x⇧-⇧1 ⊗ x) ⊗ z"
using asoc by simp
then show "y = z"
using neutroI and inversoI by simp
next
assume "y = z"
then show "x ⊗ y = x ⊗ z"
by simp
qed

thm grupo2.cancelativa_izq

text ‹Se genera el teorema grupo.cancelativa_izq
class.grupo2 ?mult ?neutro ?inverso ⟹
(?mult ?x ?y = ?mult ?x ?z) = (?y = ?z)

El teorema se aplica automáticamente a todas las instancias de la
clase grupo. Por ejemplo, a los enteros.›

subsection ‹Definiciones derivadas›

text ‹En los monoides se define la potencia natural por
· x^0 = 1
· x^{n+1} = x*x^n
›

fun (in monoide) potencia_nat :: "nat ⇒ 'a ⇒ 'a" where
"potencia_nat 0 x = 𝟭"
| "potencia_nat (Suc n) x = x ⊗ potencia_nat n x"

subsection ‹Analogía entre clases y functores›

text ‹Las listas con la operación de concatenación y la lista vacía
como elemento neutro forman un monoide.›

interpretation list_monoide: monoide "append" "[]"
proof
show "⋀x y z. (x @ y) @ z = x @ (y @ z)" by simp
next
show "⋀x. [] @ x = x" by simp
next
show "⋀x. x @ [] = x" by simp
qed

text ‹Se pueden aplicar propiedades de los monides a las listas. Por
ejemplo,›

lemma "append [] xs = xs"
by simp

text ‹(repite n xs) es la lista obtenida concatenando n veces la lista
xs.›

fun repite :: "nat ⇒ 'a list ⇒ 'a list" where
"repite 0 _ = []"
| "repite (Suc n) xs = xs @ repite n xs"

text ‹Las listas con la operación de concatenación y la lista vacía como elemento
neutro forman un monoide. Además, la potencia natural se intepreta
como repite.›

interpretation list_monoide: monoide "append" "[]" rewrites
"monoide.potencia_nat append [] = repite"
proof -
interpret monoide "append" "[]" ..
show "monoide.potencia_nat append [] = repite"
proof
fix n
show "monoide.potencia_nat append [] n = repite n"
by (induct n) auto
qed
qed intro_locales

subsection ‹Relaciones de subclase adicionales›

text ‹Los grupos son monoides.›

subclass (in grupo2) monoide
proof
fix x
have "x⇧-⇧1 ⊗ (x ⊗ 𝟭) = x⇧-⇧1 ⊗ (x ⊗ (x⇧-⇧1 ⊗ x))"
using inversoI by simp
also have "… = (x⇧-⇧1 ⊗ x) ⊗ (x⇧-⇧1 ⊗ x)"
using asoc [symmetric] by simp
also have "… = 𝟭 ⊗ (x⇧-⇧1 ⊗ x)"
using inversoI by simp
also have "… = x⇧-⇧1 ⊗ x"
using neutroI by simp
finally have "x⇧-⇧1 ⊗ (x ⊗ 𝟭) = x⇧-⇧1 ⊗ x"
by this
then show "x ⊗ 𝟭 = x"
using cancelativa_izq by simp
qed

text ‹La potencia entera en los grupos se define a partir de la potencia
natural como sigue:
· x^k = x^k si k ≥ 0
· x^k = (x^{-k})^{-1}, en caso contrario.
›

definition (in grupo2) potencia_entera :: "int ⇒ 'a ⇒ 'a" where
"potencia_entera k x =
(if k >= 0
then potencia_nat (nat k) x
else (potencia_nat (nat (- k)) x)⇧-⇧1)"

section ‹Bibliografía›

text ‹
+ "Haskell-style type classes with Isabelle/Isar" ~ F. Haftmann.
http://bit.ly/2E55pAJ
+ "Tutorial to locales and locale interpretation" ~ C. Ballarin.
http://bit.ly/2E3ozXB
›

end
</source>

Desarrollo de teorías formalizadas con Isabelle/HOL

2020-05-20T15:19:48Z

Jalonso:

<source lang="isabelle">
chapter {* Desarrollo de teorías formalizadas *}

theory T11_Desarrollo_de_teorias_formalizadas
imports Main
begin

section {* Desarrollo de la teoría de grupos*}

text {*
El objetivo de este tema es mostrar cómo se puede trabajar en
estructuras algebraicas por medio de locales. Se usará como ejemplo la
teoría de grupos. *}

text {*
Ejemplo 1. Un grupo es una estructura (G,·,𝟭,^) tal que G es un
conjunto, · es una operación binaria en G, 𝟭 es un elemento de G y ^
es una función de G en G tales que se cumplen las siguientes
propiedades:
* asociativa: ∀x y z. x ⋅ (y ⋅ z) = (x ⋅ y) ⋅ z
* neutro por la izquierda: ∀x. 𝟭 ⋅ x = x
* inverso por la izquierda: ∀x. x^ ⋅ x = 𝟭
Definir el entorno axiomático de los grupos. *}

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and inverso_i: "x^ ⋅ x = 𝟭"

text {*
Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y <one> (sin espacio entre ellos).
* El inverso de x es x^ y se escribe con pulsando 2 veces en ^. *}

text {*
A continuación se crea un contexto en el que se supone la notación y
axiomas de grupos. En el contexto se demuestran propiedades de los
grupos. *}

context grupo
begin

text {*
Ejemplo 2. En los grupos, x^ también es el inverso de x por la
derecha; es decir
x ⋅ x^ = 𝟭 *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "x ⋅ x^ = 𝟭"
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma inverso_d:
"x ⋅ x^ = 𝟭"
proof -
have "x ⋅ x^ = 𝟭 ⋅ (x ⋅ x^)" by (simp only: neutro_i)
also have "… = (𝟭 ⋅ x) ⋅ x^" by (simp only: asociativa)
also have "… = (((x^)^ ⋅ x^) ⋅ x) ⋅ x^" by (simp only: inverso_i)
also have "… = ((x^)^ ⋅ (x^ ⋅ x)) ⋅ x^" by (simp only: asociativa)
also have "… = ((x^)^ ⋅ 𝟭) ⋅ x^" by (simp only: inverso_i)
also have "… = (x^)^ ⋅ (𝟭 ⋅ x^)" by (simp only: asociativa)
also have "… = (x^)^ ⋅ x^" by (simp only: neutro_i)
also have "… = 𝟭" by (simp only: inverso_i)
finally show ?thesis .
qed

text {*
Ejemplo 2. En los grupos, 𝟭 también es el neutro por la derecha; es decir
x ⋅ 𝟭 = x *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "x ⋅ 𝟭 = x"
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma neutro_d:
"x ⋅ 𝟭 = x"
proof -
have "x ⋅ 𝟭 = x ⋅ (x^ ⋅ x)" by (simp only: inverso_i)
also have "… = (x ⋅ x^) ⋅ x" by (simp only: asociativa)
also have "… = 𝟭 ⋅ x" by (simp only: inverso_d)
also have "… = x" by (simp only: neutro_i)
finally show "x ⋅ 𝟭 = x" .
qed

text {*
Ejemplo 3. En los grupos, se tiene la propiedad cancelativa por la
izquierda; es decir,
x ⋅ y = x ⋅ z syss y = z *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x ⋅ y = x ⋅ z) = (y = z)"
by (metis asociativa inverso_i neutro_i)

― ‹La demostración detallada es›
lemma cancelativa_i:
"(x ⋅ y = x ⋅ z) = (y = z)"
proof
assume "x ⋅ y = x ⋅ z"
hence "x^ ⋅ (x ⋅ y) = x^ ⋅ (x ⋅ z)" by simp
hence "(x^ ⋅ x) ⋅ y = (x^ ⋅ x) ⋅ z" by (simp only: asociativa)
hence "𝟭 ⋅ y = 𝟭 ⋅ z" by (simp only: inverso_i)
thus "y = z" by (simp only: neutro_i)
next
assume "y = z"
then show "x ⋅ y = x ⋅ z" by simp
qed

text {*
Ejemplo 4. En los grupos, el elemento neutro por la izquierda es
único; es decir, si e es un elemento tal que para todo x se tiene que
e ⋅ x = x, entonces e = 𝟭. *}

― ‹La demostración automática es (obtenida con Sledgehammer) es›
lemma
assumes "e ⋅ x = x"
shows "𝟭 = e"
using assms
by (metis asociativa inverso_d neutro_d)

― ‹La demostración estructurada es›
lemma unicidad_neutro_i:
assumes "e ⋅ x = x"
shows "𝟭 = e"
proof -
have "𝟭 = x ⋅ x^" by (simp only: inverso_d)
also have "... = (e ⋅ x) ⋅ x^" using assms by simp
also have "... = e ⋅ (x ⋅ x^)" by (simp only: asociativa)
also have "... = e ⋅ 𝟭" by (simp only: inverso_d)
also have "... = e" by (simp only: neutro_d)
finally show ?thesis .
qed

text {*
Ejemplo 5. En los grupos, los inversos por la izquierda son únicos; es
decir, si x' es un elemento tal que x' ⋅ x = 𝟭, entonces x^ x'. *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma
assumes "x' ⋅ x = 𝟭"
shows "x^ = x'"
using assms
by (metis asociativa inverso_i neutro_i)

― ‹La demostración estructurada es›
lemma unicidad_inverso_i:
assumes "x' ⋅ x = 𝟭"
shows "x^ = x'"
proof -
have "x^ = 𝟭 ⋅ x^" by (simp only: neutro_i)
also have "... = (x' ⋅ x) ⋅ x^" using assms by simp
also have "... = x' ⋅ (x ⋅ x^)" by (simp only: asociativa)
also have "... = x' ⋅ 𝟭" by (simp only: inverso_d)
also have "... = x'" by (simp only: neutro_d)
finally show ?thesis .
qed

text {*
Ejemplo 6. En los grupos, es inverso de un producto es el producto de
los inversos cambiados de orden; es decir,
(x ⋅ y)^ = y^ ⋅ x^ *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x ⋅ y)^ = y^ ⋅ x^"
by (metis asociativa inverso_d neutro_d)

― ‹La demostración detallada es›
lemma inversa_producto:
"(x ⋅ y)^ = y^ ⋅ x^"
proof (rule unicidad_inverso_i)
show "(y^ ⋅ x^) ⋅ (x ⋅ y) = 𝟭"
proof -
have "(y^ ⋅ x^) ⋅ (x ⋅ y) = (y^ ⋅ (x^ ⋅ x)) ⋅ y" by (simp only: asociativa)
also have "... = (y^ ⋅ 𝟭) ⋅ y" by (simp only: inverso_i)
also have "... = y^ ⋅ y" by (simp only: neutro_d)
also have "... = 𝟭" by (simp only: inverso_i)
finally show ?thesis .
qed
qed

text {*
Ejemplo 7. En los grupos, el inverso del inverso es el propio
elemento; es decir,
(x^)^ = x *}

― ‹La demostración automática (obtenida con Sledgehammer) es›
lemma "(x^)^ = x"
using inverso_d unicidad_inverso_i by blast

― ‹La demostración estructurada es›
lemma inverso_inverso:
"(x^)^ = x"
proof (rule unicidad_inverso_i)
show "x ⋅ x^ = 𝟭" by (simp only: inverso_d)
qed

text {*
Ejemplo 8. En los grupos, la función inversa es inyectiva; es decir,
si x e y tienen los mismos inversos, entonces son iguales. *}

― ‹La demostración automática es (obtenida con Sledgehammer) es›
lemma
assumes "x^ = y^"
shows "x = y"
using assms
by (metis inverso_inverso)

― ‹La demostración automática estructurada es›
lemma inversa_inyectiva:
assumes "x^ = y^"
shows "x = y"
proof -
have "(x^)^ = (y^)^" using assms by simp
thus "x = y" by (simp only: inverso_inverso)
qed

end

section {* Teorías de órdenes mediante clases *}

text {*
El tutorial sobre clases está en la teoría Clases.thy.

La clase de los órdenes es la colección de los tipos que poseen una
relación ≼ verificando las siguientes propiedades
· reflexiva: x ≼ x
· transitiva: ⟦x ≼ y; y ≼ z⟧ ⟹ x ≼ z
· antisimétrica: ⟦x ≼ y; y ≼ x⟧ ⟹ x = y
*}

class orden =
fixes menor_ig :: "'a ⇒ 'a ⇒ bool" (infix "≼" 50)
assumes refl: "x ≼ x"
and trans: "⟦x ≼ y; y ≼ z⟧ ⟹ x ≼ z"
and antisim: "⟦x ≼ y; y ≼ x⟧ ⟹ x = y"

text {*
Ha generado los teoremas correspondientes a los axiomas. Pueden consultarse
mediante thm como se muestra a continuación.
*}

thm trans

text {*
Se inicia el contexto orden en el que se van a realizar definiciones y
demostraciones.
*}

context orden
begin

text {*
x es menor que y si x es menor o igual que y y no son iguales.
*}

definition menor :: "'a ⇒ 'a ⇒ bool" (infix "≺" 50)
where "x ≺ y ⟷ x ≼ y ∧ ¬ y ≼ x"

text {*
La relación menor es irreflexiva.
*}

lemma irrefl: "¬ x ≺ x"
by (auto simp: menor_def)

text {*
La relación menor es transitiva.
*}

(* Demostración aplicativa *)
lemma "⟦x ≺ y; y ≺ z⟧ ⟹ x ≺ z"
apply (unfold menor_def)
(* ⟦x ≼ y ∧ ¬ y ≼ x; y ≼ z ∧ ¬ z ≼ y⟧ ⟹ x ≼ z ∧ ¬ z ≼ x *)
apply (auto intro: trans)
(* *)
done

(* Demostración automática *)
lemma menor_trans: "⟦x ≺ y; y ≺ z⟧ ⟹ x ≺ z"
by (auto simp: menor_def intro: trans)

text {*
La relación menor es asimétrica; es decir, si x ≺ y e y ≺ x, entonces
se verifica cualquier propiedad P.
*}

lemma asimetrica: "x ≺ y ⟹ y ≺ x ⟹ P"
by (auto simp: menor_def)

end

subsection {* Subclase *}

text {*
Un orden lineal es un orden en que cada par de elementos son comparables.
*}

class ordenLineal = orden +
assumes lineal: "x ≼ y ∨ y ≼ x"
begin

text {*
En los órdenes lineales se tiene que x ≺ y ∨ x = y ∨ y ≺ x.
*}

(* Demostración aplicativa *)
lemma "x ≺ y ∨ x = y ∨ y ≺ x"
apply (unfold menor_def)
(* (x ≼ y ∧ ¬ y ≼ x) ∨ x = y ∨ (y ≼ x ∧ ¬ x ≼ y) *)
apply auto
(* 1. ⟦x ≠ y; ¬ x ≼ y⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (cut_tac x=x and y=y in lineal)
(* 1. ⟦x ≠ y; ¬ x ≼ y; x ≼ y ∨ y ≼ x⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (erule disjE)
(* 1. ⟦x ≠ y; ¬ x ≼ y; x ≼ y⟧ ⟹ y ≼ x
2. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
3. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (erule_tac P="x ≼ y" in notE)
(* 1. ⟦x ≠ y; x ≼ y⟧ ⟹ x ≼ y
2. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
3. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; ¬ x ≼ y; y ≼ x⟧ ⟹ y ≼ x
2. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; y ≼ x; x ≼ y⟧ ⟹ False *)
apply (drule antisim)
(* 1. ⟦x ≠ y; x ≼ y⟧ ⟹ x ≼ y
2. ⟦x ≠ y; x ≼ y; y = x⟧ ⟹ False *)
apply assumption
(* 1. ⟦x ≠ y; x ≼ y; y = x⟧ ⟹ False *)
apply (erule notE)
(* 1. ⟦x ≼ y; y = x⟧ ⟹ x = y *)
apply (erule sym)
(* *)
done

(* Demostración automática *)
lemma "x ≺ y ∨ x = y ∨ y ≺ x"
using menor_def lineal antisim
by blast

end

section {* Teoría de órdenes mediante ámbitos ("Locales") *}

text {*
Un orden es una estructura con una relación reflexiva, transitiva y
antisimétrica.
*}

locale Orden =
fixes menor_ig :: "'a ⇒ 'a ⇒ bool" (infix "⊑" 50)
assumes refl: "x ⊑ x"
and trans: "⟦x ⊑ y; y ⊑ z⟧ ⟹ x ⊑ z"
and antisim: "⟦x ⊑ y; y ⊑ x⟧ ⟹ x = y"

text {*
Los teoremas se diferencian por el nombre y el ámbito. Por ejemplo,
refl: ?x ≼ ?x
Orden.refl: Orden ?menor_ig ⟹ ?menor_ig ?x ?x
Orden_def: Orden ?menor_ig ≡
(∀x. ?menor_ig x x) ∧
(∀x y z. ?menor_ig x y ⟶ ?menor_ig y z ⟶ ?menor_ig x z) ∧
(∀x y. ?menor_ig x y ⟶ ?menor_ig y x ⟶ x = y)
*}

thm refl
thm Orden.refl
thm Orden_def

text {*
Un orden lineal es un orden en el que todos los pares de elementos son
comparables.
*}

locale OrdenLineal = Orden +
assumes lineal: "x ⊑ y ∨ y ⊑ x"

text {*
Los boooleanos está ordenados con el condicional.
*}

interpretation Orden_imp: Orden "λx y. x ⟶ y"
proof
fix P show "P ⟶ P" by blast
next
fix P Q R show "P ⟶ Q ⟹ Q ⟶ R ⟹ P ⟶ R" by blast
next
fix P Q show "P ⟶ Q ⟹ Q ⟶ P ⟹ P = Q" by blast
qed

text {*
Los naturales con la relación de divisibilidad es un conjunto ordenado.
*}

interpretation Orden_dvd: Orden "(dvd) :: nat ⇒ nat ⇒ bool"
proof
fix x :: nat
show "x dvd x" using dvd_refl by simp
next
fix x y z :: nat
show "⟦x dvd y; y dvd z⟧ ⟹ x dvd z" using dvd_trans by auto
next
fix x y :: nat
show "⟦x dvd y; y dvd x⟧ ⟹ x = y" using dvd_antisym by simp
qed

text {*
Ámbito de las funciones monótonas (ver la página 12 del tutorial de
locales).
*}

locale Mono =
le1: Orden le1 +
le2: Orden le2
for le1 (infix "⊑⇩1" 50) and le2 (infix "⊑⇩2" 50) +
fixes f :: "'a ⇒ 'b"
assumes mono: "x ⊑⇩1 y ⟹ f(x) ⊑⇩2 f(y)"

text {*
Si f es monótona, x ⊑_1 y e y ⊑_1 z, entonces f(x) ⊑_2 f(z).
*}

lemma (in Mono) mono_trans:
assumes "x ⊑⇩1 y" and "y ⊑⇩1 z"
shows "f(x) ⊑⇩2 f(z)"
proof -
have "x ⊑⇩1 z" using assms and le1.trans by blast
then show "f(x) ⊑⇩2 f(z)" using mono by simp
qed

text {*
El teorema generado se llama Mono.mono_trans.
*}

thm Mono.mono_trans

text {*
En el contexto Mono el nombre es mono_trans.
*}

context Mono
begin
thm mono_trans
end

text {*
El predicado `ser par' es un operador monótono entre los naturales con la
relación de divisibilidad y los booleanos con el condicional; es decir,
x dvd y ⟹ even x ⟶ even y
*}

interpretation Mono "(dvd)" "(⟶)" "λn::nat. 2 dvd n"
proof
fix x y :: nat
show "x dvd y ⟹ even x ⟶ even y"
proof
assume "x dvd y" and "even x"
then show "even y"
using Rings.comm_monoid_mult_class.dvd_trans by auto
qed
qed

section {* Semigrupos, monoides y grupos *}

subsection {* Definición de clases *}

text {*
Un semigrupo es una estructura compuesta por un conjunto A y una
operación binaria en A.
*}

class semigrupo =
fixes mult :: "'a ⇒ 'a ⇒ 'a" (infixl "⊗" 70)
assumes asoc: "(x ⊗ y) ⊗ z = x ⊗ (y ⊗ z )"

subsection {* Instanciación de clases *}

text {*
Los enteros con la suma forman un semigrupo.
*}

instantiation int :: semigrupo
begin
definition
mult_int_def: "i ⊗ j = i + (j ::int)"

instance proof
fix i j k :: "int"
have "(i + j ) + k = i + (j + k)" by simp
then show "(i ⊗ j ) ⊗ k = i ⊗ (j ⊗ k)" unfolding mult_int_def .
qed
end

text {*
Los naturales con la suma forman un semigrupo.
*}

instantiation nat :: semigrupo
begin
primrec mult_nat where
"(0::nat) ⊗ n = n"
| "Suc m ⊗ n = Suc (m ⊗ n)"

instance proof
fix m n q :: "nat"
show "m ⊗ n ⊗ q = m ⊗ (n ⊗ q)"
by (induct m) auto
qed
end

subsection {* Instancias recursivas *}

text {*
Si (A,⊗) y (B,⊗) son semigrupos, entonces ((A×B,⊗), donde el producto
se define por
(x,y)⊗(x',y') = (x⊗x',y⊗y'),
es un semigrupo.
*}

instantiation prod :: (semigrupo, semigrupo) semigrupo
begin

definition
mult_prod_def : "p1 ⊗ p2 = (fst p1 ⊗ fst p2, snd p1 ⊗ snd p2)"

instance proof
fix p1 p2 p3 :: "'a::semigrupo × 'b::semigrupo"
show "(p1 ⊗ p2) ⊗ p3 = p1 ⊗ (p2 ⊗ p3)"
unfolding mult_prod_def by (simp add: asoc)
qed
end

subsection {* Subclases *}

text {*
Un monoide izquierdo es un semigrupo con elemento neutro por la izquierda.
*}

class monoideI = semigrupo +
fixes neutro :: "'a" ("𝟭")
assumes neutroI: "𝟭 ⊗ x = x"

text {*
Los naturales y los enteros con la suma forman monoides por la izquierda.
*}

instantiation nat and int :: monoideI
begin

definition
neutro_nat_def : "𝟭 = (0::nat)"

definition
neutro_int_def : "𝟭 = (0::int)"

instance proof
fix n :: nat
show "𝟭 ⊗ n = n" unfolding neutro_nat_def by simp
next
fix k :: int
show "𝟭 ⊗ k = k" unfolding neutro_int_def mult_int_def by simp
qed
end

text {*
El producto de dos monoides por la izquierda es un monoide por la
izquierda, donde el neutro es el par formado por los elementos neutros.
*}

instantiation prod :: (monoideI , monoideI) monoideI
begin

definition
neutro_prod_def : "𝟭 = (𝟭, 𝟭)"

instance proof
fix p :: "'a::monoideI × 'b::monoideI"
show "𝟭 ⊗ p = p"
unfolding neutro_prod_def mult_prod_def by (simp add: neutroI)
qed
end

text {*
Un monoide es un monoide por la izquierda cuyo elemento neutro por la
izquierda lo es también por la derecha.
*}

class monoide = monoideI +
assumes neutro: "x ⊗ 𝟭 = x"

text {*
Los naturales y los enteros con la suma son monoides.
*}

instantiation nat and int :: monoide
begin

instance proof
fix n :: nat
show "n ⊗ 𝟭 = n"
unfolding neutro_nat_def by (induct n) simp_all
next
fix k :: int
show "k ⊗ 𝟭 = k"
unfolding neutro_int_def mult_int_def by simp
qed
end

text {*
El producto de dos monoides es un monoide.
*}

instantiation prod :: (monoide, monoide) monoide
begin

instance proof
fix p :: "'a::monoide × 'b::monoide"
show "p ⊗ 𝟭 = p"
unfolding neutro_prod_def mult_prod_def by (simp add: neutro)
qed
end

text {*
Un grupo es un monoide por la izquierda tal que todo elemento posee un
inverso por la izquierda.
*}

class grupo2 = monoideI +
fixes inverso :: "'a ⇒ 'a" ("(_⇧-⇧1)" [1000] 999)
assumes inversoI: "x⇧-⇧1 ⊗ x = 𝟭"

text {*
Los enteros con la suma forman un grupo.
*}

instantiation int :: grupo2
begin

definition
inverso_int_def: "i⇧-⇧1 = -(i::int)"

instance proof
fix i :: "int"
have "-i + i = 0" by simp
then show "i⇧-⇧1 ⊗ i = 𝟭"
unfolding mult_int_def neutro_int_def inverso_int_def .
qed
end

subsection {* Razonamiento abstracto *}

text {*
En los grupos se verifica la propiedad cancelativa por la izquierda, i.e.
x ⊗ y = x ⊗ z ⟷ y = z
*}

lemma (in grupo2) cancelativa_izq: "x ⊗ y = x ⊗ z ⟷ y = z"
proof
assume "x ⊗ y = x ⊗ z"
hence "x⇧-⇧1 ⊗ (x ⊗ y) = x⇧-⇧1 ⊗ (x ⊗ z)" by simp
hence "(x⇧-⇧1 ⊗ x) ⊗ y = (x⇧-⇧1 ⊗ x) ⊗ z" using asoc by simp
then show "y = z" using neutroI and inversoI by simp
next
assume "y = z"
then show "x ⊗ y = x ⊗ z" by simp
qed

thm grupo2.cancelativa_izq

text {*
Se genera el teorema grupo.cancelativa_izq
class.grupo2 ?mult ?neutro ?inverso ⟹
(?mult ?x ?y = ?mult ?x ?z) = (?y = ?z)

El teorema se aplica automáticamente a todas las instancias de la clase
grupo. Por ejemplo, a los enteros.
*}

subsection {* Definiciones derivadas *}

text {*
En los monoides se define la potencia natural por
· x^0 = 1
· x^{n+1} = x*x^n
*}

fun (in monoide) potencia_nat :: "nat ⇒ 'a ⇒ 'a" where
"potencia_nat 0 x = 𝟭"
| "potencia_nat (Suc n) x = x ⊗ potencia_nat n x"

subsection {* Analogía entre clases y functores *}

text {*
Las listas con la operación de concatenación y la lista vacía como elemento
neutro forman un monoide.
*}

interpretation list_monoide: monoide "append" "[]"
proof
show "⋀x y z. (x @ y) @ z = x @ (y @ z)" by simp
next
show "⋀x. [] @ x = x" by simp
next
show "⋀x. x @ [] = x" by simp
qed

text {*
Se pueden aplicar propiedades de los monides a las listas. Por ejemplo,
*}

lemma "append [] xs = xs"
by simp

text {*
(repite n xs) es la lista obtenida concatenando n veces la lista xs.
*}

fun repite :: "nat ⇒ 'a list ⇒ 'a list" where
"repite 0 _ = []"
| "repite (Suc n) xs = xs @ repite n xs"

text {*
Las listas con la operación de concatenación y la lista vacía como elemento
neutro forman un monoide. Además, la potencia natural se intepreta como
repite.
*}

interpretation list_monoide: monoide "append" "[]" rewrites
"monoide.potencia_nat append [] = repite"
proof -
interpret monoide "append" "[]" ..
show "monoide.potencia_nat append [] = repite"
proof
fix n
show "monoide.potencia_nat append [] n = repite n"
by (induct n) auto
qed
qed intro_locales

subsection {* Relaciones de subclase adicionales *}

text {*
Los grupos son monoides.
*}

subclass (in grupo2) monoide
proof
fix x
have "x⇧-⇧1 ⊗ (x ⊗ 𝟭) = x⇧-⇧1 ⊗ (x ⊗ (x⇧-⇧1 ⊗ x))" using inversoI by simp
also have "… = (x⇧-⇧1 ⊗ x) ⊗ (x⇧-⇧1 ⊗ x)" using asoc [symmetric] by simp
also have "… = 𝟭 ⊗ (x⇧-⇧1 ⊗ x)" using inversoI by simp
also have "… = x⇧-⇧1 ⊗ x" using neutroI by simp
finally have "x⇧-⇧1 ⊗ (x ⊗ 𝟭) = x⇧-⇧1 ⊗ x" .
then show "x ⊗ 𝟭 = x" using cancelativa_izq by simp
qed

text {*
La potencia entera en los grupos se define a partir de la potencia natural
como sigue:
· x^k = x^k si k ≥ 0
· x^k = (x^{-k})^{-1}, en caso contrario.
*}

definition (in grupo2) potencia_entera :: "int ⇒ 'a ⇒ 'a" where
"potencia_entera k x =
(if k >= 0
then potencia_nat (nat k) x
else (potencia_nat (nat (- k)) x)⇧-⇧1)"

section {* Bibliografía *}
text {*
+ "Haskell-style type classes with Isabelle/Isar" ~ F. Haftmann.
http://bit.ly/2E55pAJ
+ "Tutorial to locales and locale interpretation" ~ C. Ballarin.
http://bit.ly/2E3ozXB
*}

end
</source>

Razonamiento sobre árboles y bosques

2020-05-14T06:02:22Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 8: Razonamiento sobre árboles›

theory T8_Razonamiento_sobre_arboles
imports Main
begin

text ‹En este tema se estudia razonamiento sobre otras estructuras
recursivas como árboles binarios, árboles generales y bosques.

También se muestra cómo definir tipos de datos por recursión cruzada y
la demostración de sus propiedades por inducción.›

section ‹Razonamiento sobre árboles binarios›

text ‹Ejemplo de definición de tipos recursivos:
Definir un tipo de dato para los árboles binarios.›

datatype 'a arbolB = Hoja "'a"
| Nodo "'a" "'a arbolB" "'a arbolB"

text ‹Regla de inducción correspondiente a los árboles binarios:
La regla de inducción sobre árboles binarios es arbol.induct:
⟦ ⋀x. P (Hoja x);
⋀x i d. ⟦P i; P d⟧ ⟹ P (Nodo x i d)⟧
⟹ P a
›

thm arbolB.induct

text ‹Ejemplo de definición sobre árboles binarios:
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.›

fun espejo :: "'a arbolB ⇒ 'a arbolB" where
"espejo (Hoja x) = Hoja x"
| "espejo (Nodo x i d) = Nodo x (espejo d) (espejo i)"

value "espejo (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
Nodo a (Hoja e) (Nodo b (Hoja d) (Hoja c))"

text ‹Ejemplo de demostración sobre árboles binarios:
Demostrar que la función "espejo" es involutiva; es decir, para
cualquier árbol a, se tiene que
espejo (espejo a) = a.›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))" by simp
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by simp
also have "… = Nodo x i d"
using h1 h2 by simp
finally show ?thesis .
qed
qed

― ‹La demostración declarativa detallada es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by (simp only: espejo.simps(1))
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by (simp only: espejo.simps(2))
also have "… = Nodo x i d"
by (simp only: h1 h2)
finally show ?thesis
by this
qed
qed

text ‹Comentarios sobre la demostración anterior:
· (fixes a :: "'b arbolB") es una abreviatura de "sea a1 un árbol binario
cuyos elementos son de tipo b".
· (induct a) indica que el método de demostración es por inducción
en el árbol binario a.
· Se generan dos casos:
1. ⋀a. espejo (espejo (Hoja a)) = Hoja a
2. ⋀a1 a2 a3. ⟦espejo (espejo a2) = a2;
espejo (espejo a3) = a3⟧
⟹ espejo (espejo (Nodo a1 a2 a3)) = Nodo a1 a2 a3›

― ‹La demostración aplicativa es›
lemma
"espejo (espejo a) = a"
apply (induct a)
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma
"espejo (espejo a) = a"
apply (induct a)
apply (simp only: espejo.simps(1))
apply (simp only: espejo.simps(2))
done

― ‹La demostración automática es›
lemma
"espejo (espejo a) = a"
by (induct a) simp+

― ‹La demostración automática detallada es›
lemma
"espejo (espejo a) = a"
by (induct a) (simp only: espejo.simps)+

text ‹Ejemplo. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.›

fun aplana :: "'a arbolB ⇒ 'a list" where
"aplana (Hoja x) = [x]"
| "aplana (Nodo x i d) = aplana i @ [x] @ aplana d"

value "aplana (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
[c, b, d, a, e]"

text ‹Ejemplo. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo a) = rev (aplana a)›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by simp
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by simp
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
using h1 h2 by simp
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by simp
also have "… = rev (aplana (Nodo x i d))"
by simp
finally show ?thesis .
qed
qed

― ‹Lema auxiliar para la demostración declarativa detallada›
lemma rev_unit: "rev [x] = [x]"
proof -
have "rev [x] = rev [] @ [x]"
by (simp only: rev.simps(2))
also have "… = [] @ [x]"
by (simp only: rev.simps(1))
also have "… = [x]"
by (simp only: append.simps(1))
finally show ?thesis
by this
qed

― ‹La demostración estructurada y detallada es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x :: 'b
have "aplana (espejo (Hoja x)) = aplana (Hoja x)"
by (simp only: espejo.simps(1))
also have "… = [x]"
by (simp only: aplana.simps(1))
also have "… = rev [x]"
by (simp only: rev_unit)
also have "… = rev (aplana (Hoja x))"
by (simp only: aplana.simps(1))
finally show "?P (Hoja x)"
by this
next
fix x :: 'b
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by (simp only: aplana.simps(2))
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
by (simp only: h1 h2)
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by (simp only: rev_append rev_unit append_assoc)
also have "… = rev (aplana (Nodo x i d))"
by (simp only: aplana.simps(2))
finally show ?thesis
by this
qed
qed

― ‹La demostración aplicativa es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only: espejo.simps(1) aplana.simps(1))
apply (simp only: rev_unit)
apply (simp only: espejo.simps(2) aplana.simps(2))
apply (simp only: rev_append)
apply (simp only: rev_unit)
apply (simp only: append_assoc)
done

― ‹La demostración aplicativa detallada compacta es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only:
espejo.simps(1)
aplana.simps(1)
rev_unit
espejo.simps(2)
aplana.simps(2)
rev_append
append_assoc)+
done

― ‹La demostración aplicativa detallada más compacta es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only:
espejo.simps
aplana.simps
rev_unit
rev_append
append_assoc)+
done

― ‹La demostración automática es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a) simp_all

― ‹La demostración automática detallada es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a)
(simp only:
espejo.simps
aplana.simps
rev_unit
rev_append
append_assoc)+

section ‹Árboles y bosques. Recursión mutua e inducción›

text ‹Nota. [Ejemplo de definición de tipos mediante recursión cruzada]
· Un árbol de tipo a es una hoja o un nodo de tipo a junto con un
bosque de tipo a.
· Un bosque de tipo a es el boque vacío o un bosque contruido añadiendo
un árbol de tipo a a un bosque de tipo a.›

datatype 'a arbol = Nodo "'a" "'a bosque"
and 'a bosque = Vacio | ConsB "'a arbol" "'a bosque"

text ‹Regla de inducción correspondiente a la recursión cruzada:
La regla de inducción sobre árboles y bosques es arbol_bosque.induct:
⟦⋀x b. P2 b ⟹ P1 (Nodo x b);
P2 Vacio;
⋀a b. ⟦P1 a; P2 b⟧ ⟹ P2 (ConsB a b)⟧
⟹ P1 a ∧ P2 b›

thm arbol_bosque.induct

text ‹Ejemplos de definición por recursión cruzada:
· aplana_arbol a) es la lista obtenida aplanando el árbol a.
· (aplana_bosque b) es la lista obtenida aplanando el bosque b.
· (map_arbol f a) es el árbol obtenido aplicando la función f a
todos los nodos del árbol a.
· (map_bosque f b) es el bosque obtenido aplicando la función f a
todos los nodos del bosque b. ›

fun aplana_arbol :: "'a arbol ⇒ 'a list" and
aplana_bosque :: "'a bosque ⇒ 'a list" where
"aplana_arbol (Nodo x b) = x # (aplana_bosque b)"
| "aplana_bosque Vacio = []"
| "aplana_bosque (ConsB a b) = (aplana_arbol a) @ (aplana_bosque b)"

fun map_arbol :: "('a ⇒ 'b) ⇒ 'a arbol ⇒ 'b arbol" and
map_bosque :: "('a ⇒ 'b) ⇒ 'a bosque ⇒ 'b bosque" where
"map_arbol f (Nodo x b) = Nodo (f x) (map_bosque f b)"
| "map_bosque f Vacio = Vacio"
| "map_bosque f (ConsB a b) = ConsB (map_arbol f a) (map_bosque f b)"

text ‹Ejemplo de demostración por inducción cruzada:
Demostrar que:
· aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
· aplana_bosque (map_bosque f b) = map f (aplana_bosque b)›

declare [[names_short]]

― ‹La demostración declarativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by simp
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by simp
also have "… = (f x) # (map f (aplana_bosque b))"
using HI by simp
also have "… = map f (aplana_arbol (Nodo x b))"
by simp
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by simp
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))" by simp
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by simp
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
using HI1 HI2 by simp
also have "… = map f (aplana_bosque (ConsB a b))" by simp
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

― ‹La demostración declarativa detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by (simp only: map_arbol.simps(1))
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by (simp only: aplana_arbol.simps(1))
also have "… = (f x) # (map f (aplana_bosque b))"
by (simp only: HI)
also have "… = map f (aplana_arbol (Nodo x b))"
by (simp only: list.map aplana_arbol.simps(1))
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by (simp only: aplana_bosque.simps(1)
map_bosque.simps(1)
list.map)
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))"
by (simp only: map_bosque.simps(2))
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by (simp only: aplana_bosque.simps(2))
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
by (simp only: HI1 HI2)
also have "… = map f (aplana_arbol a @ aplana_bosque b)"
by (simp only: map_append)
also have "… = map f (aplana_bosque (ConsB a b))"
by (simp only: aplana_bosque.simps(2))
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

text ‹Comentarios sobre la demostración anterior:
· (induct_tac a and b) indica que el método de demostración es por
inducción cruzada sobre a y b.
· Se generan 3 casos:
1. ⋀a bosque.
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque) ⟹
aplana_arbol (map_arbol (arbol.Nodo a bosque) h) =
map h (aplana_arbol (arbol.Nodo a bosque))
2. aplana_bosque (map_bosque Vacio h) = map h (aplana_bosque Vacio)
3. ⋀arbol bosque.
⟦aplana_arbol (map_arbol arbol h) = map h (aplana_arbol arbol);
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque)⟧
⟹ aplana_bosque (map_bosque (ConsB arbol bosque) h) =
map h (aplana_bosque (ConsB arbol bosque))›

― ‹La demostración aplicativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply simp
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only: map_arbol.simps aplana_arbol.simps)
apply (simp only: list.map(2))
apply (simp only: map_bosque.simps(1) aplana_bosque.simps(1))
apply (simp only: list.map(1))
apply (simp only: map_bosque.simps(2) aplana_bosque.simps(2))
apply (simp only: map_append)
done

― ‹La demostración aplicativa detallada compacta es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only:
map_arbol.simps
aplana_arbol.simps
list.map(2)
map_bosque.simps(1)
aplana_bosque.simps(1)
list.map(1)
map_bosque.simps(2)
aplana_bosque.simps(2)
map_append)+
done

― ‹La demostración aplicativa detallada más compacta es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only:
map_arbol.simps
map_bosque.simps
aplana_arbol.simps
aplana_bosque.simps
list.map
map_append)+
done

― ‹La demostración automática es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b) simp_all

― ‹La demostración automática detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b)
(simp only:
map_arbol.simps
map_bosque.simps
aplana_arbol.simps
aplana_bosque.simps
list.map
map_append)+
end
</source>

Razonamiento sobre árboles y bosques

2020-05-14T06:00:37Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 8: Razonamiento sobre árboles›

theory T8_Razonamiento_sobre_arboles
imports Main HOL.Parity
begin

text ‹En este tema se estudia razonamiento sobre otras estructuras
recursivas como árboles binarios, árboles generales y bosques.

También se muestra cómo definir tipos de datos por recursión cruzada y
la demostración de sus propiedades por inducción.›

section ‹Razonamiento sobre árboles binarios›

text ‹Ejemplo de definición de tipos recursivos:
Definir un tipo de dato para los árboles binarios.›

datatype 'a arbolB = Hoja "'a"
| Nodo "'a" "'a arbolB" "'a arbolB"

text ‹Regla de inducción correspondiente a los árboles binarios:
La regla de inducción sobre árboles binarios es arbol.induct:
⟦ ⋀x. P (Hoja x);
⋀x i d. ⟦P i; P d⟧ ⟹ P (Nodo x i d)⟧
⟹ P a
›

thm arbolB.induct

text ‹Ejemplo de definición sobre árboles binarios:
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.›

fun espejo :: "'a arbolB ⇒ 'a arbolB" where
"espejo (Hoja x) = Hoja x"
| "espejo (Nodo x i d) = Nodo x (espejo d) (espejo i)"

value "espejo (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
Nodo a (Hoja e) (Nodo b (Hoja d) (Hoja c))"

text ‹Ejemplo de demostración sobre árboles binarios:
Demostrar que la función "espejo" es involutiva; es decir, para
cualquier árbol a, se tiene que
espejo (espejo a) = a.›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))" by simp
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by simp
also have "… = Nodo x i d"
using h1 h2 by simp
finally show ?thesis .
qed
qed

― ‹La demostración declarativa detallada es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by (simp only: espejo.simps(1))
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by (simp only: espejo.simps(2))
also have "… = Nodo x i d"
by (simp only: h1 h2)
finally show ?thesis
by this
qed
qed

text ‹Comentarios sobre la demostración anterior:
· (fixes a :: "'b arbolB") es una abreviatura de "sea a1 un árbol binario
cuyos elementos son de tipo b".
· (induct a) indica que el método de demostración es por inducción
en el árbol binario a.
· Se generan dos casos:
1. ⋀a. espejo (espejo (Hoja a)) = Hoja a
2. ⋀a1 a2 a3. ⟦espejo (espejo a2) = a2;
espejo (espejo a3) = a3⟧
⟹ espejo (espejo (Nodo a1 a2 a3)) = Nodo a1 a2 a3›

― ‹La demostración aplicativa es›
lemma
"espejo (espejo a) = a"
apply (induct a)
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma
"espejo (espejo a) = a"
apply (induct a)
apply (simp only: espejo.simps(1))
apply (simp only: espejo.simps(2))
done

― ‹La demostración automática es›
lemma
"espejo (espejo a) = a"
by (induct a) simp+

― ‹La demostración automática detallada es›
lemma
"espejo (espejo a) = a"
by (induct a) (simp only: espejo.simps)+

text ‹Ejemplo. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.›

fun aplana :: "'a arbolB ⇒ 'a list" where
"aplana (Hoja x) = [x]"
| "aplana (Nodo x i d) = aplana i @ [x] @ aplana d"

value "aplana (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
[c, b, d, a, e]"

text ‹Ejemplo. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo a) = rev (aplana a)›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by simp
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by simp
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
using h1 h2 by simp
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by simp
also have "… = rev (aplana (Nodo x i d))"
by simp
finally show ?thesis .
qed
qed

― ‹Lema auxiliar para la demostración declarativa detallada›
lemma rev_unit: "rev [x] = [x]"
proof -
have "rev [x] = rev [] @ [x]"
by (simp only: rev.simps(2))
also have "… = [] @ [x]"
by (simp only: rev.simps(1))
also have "… = [x]"
by (simp only: append.simps(1))
finally show ?thesis
by this
qed

― ‹La demostración estructurada y detallada es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x :: 'b
have "aplana (espejo (Hoja x)) = aplana (Hoja x)"
by (simp only: espejo.simps(1))
also have "… = [x]"
by (simp only: aplana.simps(1))
also have "… = rev [x]"
by (simp only: rev_unit)
also have "… = rev (aplana (Hoja x))"
by (simp only: aplana.simps(1))
finally show "?P (Hoja x)"
by this
next
fix x :: 'b
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by (simp only: aplana.simps(2))
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
by (simp only: h1 h2)
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by (simp only: rev_append rev_unit append_assoc)
also have "… = rev (aplana (Nodo x i d))"
by (simp only: aplana.simps(2))
finally show ?thesis
by this
qed
qed

― ‹La demostración aplicativa es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only: espejo.simps(1) aplana.simps(1))
apply (simp only: rev_unit)
apply (simp only: espejo.simps(2) aplana.simps(2))
apply (simp only: rev_append)
apply (simp only: rev_unit)
apply (simp only: append_assoc)
done

― ‹La demostración aplicativa detallada compacta es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only:
espejo.simps(1)
aplana.simps(1)
rev_unit
espejo.simps(2)
aplana.simps(2)
rev_append
append_assoc)+
done

― ‹La demostración aplicativa detallada más compacta es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
apply (simp only:
espejo.simps
aplana.simps
rev_unit
rev_append
append_assoc)+
done

― ‹La demostración automática es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a) simp_all

― ‹La demostración automática detallada es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a)
(simp only:
espejo.simps
aplana.simps
rev_unit
rev_append
append_assoc)+

section ‹Árboles y bosques. Recursión mutua e inducción›

text ‹Nota. [Ejemplo de definición de tipos mediante recursión cruzada]
· Un árbol de tipo a es una hoja o un nodo de tipo a junto con un
bosque de tipo a.
· Un bosque de tipo a es el boque vacío o un bosque contruido añadiendo
un árbol de tipo a a un bosque de tipo a.›

datatype 'a arbol = Nodo "'a" "'a bosque"
and 'a bosque = Vacio | ConsB "'a arbol" "'a bosque"

text ‹Regla de inducción correspondiente a la recursión cruzada:
La regla de inducción sobre árboles y bosques es arbol_bosque.induct:
⟦⋀x b. P2 b ⟹ P1 (Nodo x b);
P2 Vacio;
⋀a b. ⟦P1 a; P2 b⟧ ⟹ P2 (ConsB a b)⟧
⟹ P1 a ∧ P2 b›

thm arbol_bosque.induct

text ‹Ejemplos de definición por recursión cruzada:
· aplana_arbol a) es la lista obtenida aplanando el árbol a.
· (aplana_bosque b) es la lista obtenida aplanando el bosque b.
· (map_arbol f a) es el árbol obtenido aplicando la función f a
todos los nodos del árbol a.
· (map_bosque f b) es el bosque obtenido aplicando la función f a
todos los nodos del bosque b. ›

fun aplana_arbol :: "'a arbol ⇒ 'a list" and
aplana_bosque :: "'a bosque ⇒ 'a list" where
"aplana_arbol (Nodo x b) = x # (aplana_bosque b)"
| "aplana_bosque Vacio = []"
| "aplana_bosque (ConsB a b) = (aplana_arbol a) @ (aplana_bosque b)"

fun map_arbol :: "('a ⇒ 'b) ⇒ 'a arbol ⇒ 'b arbol" and
map_bosque :: "('a ⇒ 'b) ⇒ 'a bosque ⇒ 'b bosque" where
"map_arbol f (Nodo x b) = Nodo (f x) (map_bosque f b)"
| "map_bosque f Vacio = Vacio"
| "map_bosque f (ConsB a b) = ConsB (map_arbol f a) (map_bosque f b)"

text ‹Ejemplo de demostración por inducción cruzada:
Demostrar que:
· aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
· aplana_bosque (map_bosque f b) = map f (aplana_bosque b)›

declare [[names_short]]

― ‹La demostración declarativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by simp
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by simp
also have "… = (f x) # (map f (aplana_bosque b))"
using HI by simp
also have "… = map f (aplana_arbol (Nodo x b))"
by simp
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by simp
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))" by simp
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by simp
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
using HI1 HI2 by simp
also have "… = map f (aplana_bosque (ConsB a b))" by simp
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

― ‹La demostración declarativa detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by (simp only: map_arbol.simps(1))
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by (simp only: aplana_arbol.simps(1))
also have "… = (f x) # (map f (aplana_bosque b))"
by (simp only: HI)
also have "… = map f (aplana_arbol (Nodo x b))"
by (simp only: list.map aplana_arbol.simps(1))
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by (simp only: aplana_bosque.simps(1)
map_bosque.simps(1)
list.map)
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))"
by (simp only: map_bosque.simps(2))
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by (simp only: aplana_bosque.simps(2))
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
by (simp only: HI1 HI2)
also have "… = map f (aplana_arbol a @ aplana_bosque b)"
by (simp only: map_append)
also have "… = map f (aplana_bosque (ConsB a b))"
by (simp only: aplana_bosque.simps(2))
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

text ‹Comentarios sobre la demostración anterior:
· (induct_tac a and b) indica que el método de demostración es por
inducción cruzada sobre a y b.
· Se generan 3 casos:
1. ⋀a bosque.
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque) ⟹
aplana_arbol (map_arbol (arbol.Nodo a bosque) h) =
map h (aplana_arbol (arbol.Nodo a bosque))
2. aplana_bosque (map_bosque Vacio h) = map h (aplana_bosque Vacio)
3. ⋀arbol bosque.
⟦aplana_arbol (map_arbol arbol h) = map h (aplana_arbol arbol);
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque)⟧
⟹ aplana_bosque (map_bosque (ConsB arbol bosque) h) =
map h (aplana_bosque (ConsB arbol bosque))›

― ‹La demostración aplicativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply simp
apply simp
apply simp
done

― ‹La demostración aplicativa detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only: map_arbol.simps aplana_arbol.simps)
apply (simp only: list.map(2))
apply (simp only: map_bosque.simps(1) aplana_bosque.simps(1))
apply (simp only: list.map(1))
apply (simp only: map_bosque.simps(2) aplana_bosque.simps(2))
apply (simp only: map_append)
done

― ‹La demostración aplicativa detallada compacta es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only:
map_arbol.simps
aplana_arbol.simps
list.map(2)
map_bosque.simps(1)
aplana_bosque.simps(1)
list.map(1)
map_bosque.simps(2)
aplana_bosque.simps(2)
map_append)+
done

― ‹La demostración aplicativa detallada más compacta es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
apply (simp only:
map_arbol.simps
map_bosque.simps
aplana_arbol.simps
aplana_bosque.simps
list.map
map_append)+
done

― ‹La demostración automática es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b) simp_all

― ‹La demostración automática detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b)
(simp only:
map_arbol.simps
map_bosque.simps
aplana_arbol.simps
aplana_bosque.simps
list.map
map_append)+
end
</source>

Razonamiento sobre árboles y bosques

2020-05-13T17:46:33Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 8: Razonamiento sobre árboles›

theory T8_Razonamiento_sobre_arboles
imports Main HOL.Parity
begin

text ‹En este tema se estudia razonamiento sobre otras estructuras
recursivas como árboles binarios, árboles generales y bosques.

También se muestra cómo definir tipos de datos por recursión cruzada y
la demostración de sus propiedades por inducción.›

section ‹Razonamiento sobre árboles binarios›

text ‹Ejemplo de definición de tipos recursivos:
Definir un tipo de dato para los árboles binarios.›

datatype 'a arbolB = Hoja "'a"
| Nodo "'a" "'a arbolB" "'a arbolB"

text ‹Regla de inducción correspondiente a los árboles binarios:
La regla de inducción sobre árboles binarios es arbol.induct:
⟦ ⋀x. P (Hoja x);
⋀x i d. ⟦P i; P d⟧ ⟹ P (Nodo x i d)⟧
⟹ P a
›

thm arbolB.induct

text ‹Ejemplo de definición sobre árboles binarios:
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.›

fun espejo :: "'a arbolB ⇒ 'a arbolB" where
"espejo (Hoja x) = Hoja x"
| "espejo (Nodo x i d) = Nodo x (espejo d) (espejo i)"

value "espejo (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
Nodo a (Hoja e) (Nodo b (Hoja d) (Hoja c))"

text ‹Ejemplo de demostración sobre árboles binarios:
Demostrar que la función "espejo" es involutiva; es decir, para
cualquier árbol a, se tiene que
espejo (espejo a) = a.›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))" by simp
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by simp
also have "… = Nodo x i d"
using h1 h2 by simp
finally show ?thesis .
qed
qed

― ‹La demostración declarativa detallada es›
lemma
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by (simp only: espejo.simps(1))
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by (simp only: espejo.simps(2))
also have "… = Nodo x i d"
by (simp only: h1 h2)
finally show ?thesis
by this
qed
qed

text ‹Comentarios sobre la demostración anterior:
· (fixes a :: "'b arbolB") es una abreviatura de "sea a1 un árbol binario
cuyos elementos son de tipo b".
· (induct a) indica que el método de demostración es por inducción
en el árbol binario a.
· Se generan dos casos:
1. ⋀a. espejo (espejo (Hoja a)) = Hoja a
2. ⋀a1 a2 a3. ⟦espejo (espejo a2) = a2;
espejo (espejo a3) = a3⟧
⟹ espejo (espejo (Nodo a1 a2 a3)) = Nodo a1 a2 a3›

― ‹La demostración automática es›
lemma
"espejo (espejo a) = a"
by (induct a) simp_all

text ‹Ejemplo. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.›

fun aplana :: "'a arbolB ⇒ 'a list" where
"aplana (Hoja x) = [x]"
| "aplana (Nodo x i d) = aplana i @ [x] @ aplana d"

value "aplana (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
[c, b, d, a, e]"

text ‹Ejemplo. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo a) = rev (aplana a)›

― ‹La demostración declarativa es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)"
by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by simp
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by simp
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
using h1 h2 by simp
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by simp
also have "… = rev (aplana (Nodo x i d))"
by simp
finally show ?thesis .
qed
qed

― ‹Lema auxiliar para la demostración declarativa detallada›
lemma rev_unit: "rev [x] = [x]"
proof -
have "rev [x] = rev [] @ [x]"
by (simp only: rev.simps(2))
also have "… = [] @ [x]"
by (simp only: rev.simps(1))
also have "… = [x]"
by (simp only: append.simps(1))
finally show ?thesis
by this
qed

― ‹La demostración estructurada y detallada es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x :: 'b
have "aplana (espejo (Hoja x)) = aplana (Hoja x)"
by (simp only: espejo.simps(1))
also have "… = [x]"
by (simp only: aplana.simps(1))
also have "… = rev [x]"
by (simp only: rev_unit)
also have "… = rev (aplana (Hoja x))"
by (simp only: aplana.simps(1))
finally show "?P (Hoja x)"
by this
next
fix x :: 'b
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by (simp only: aplana.simps(2))
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
by (simp only: h1 h2)
also have "… = rev ((aplana i) @ [x] @ (aplana d))"
by (simp only: rev_append rev_unit append_assoc)
also have "… = rev (aplana (Nodo x i d))"
by (simp only: aplana.simps(2))
finally show ?thesis
by this
qed
qed

― ‹La demostración automática es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a) simp_all

section ‹Árboles y bosques. Recursión mutua e inducción›

text ‹Nota. [Ejemplo de definición de tipos mediante recursión cruzada]
· Un árbol de tipo a es una hoja o un nodo de tipo a junto con un
bosque de tipo a.
· Un bosque de tipo a es el boque vacío o un bosque contruido añadiendo
un árbol de tipo a a un bosque de tipo a.›

datatype 'a arbol = Nodo "'a" "'a bosque"
and 'a bosque = Vacio | ConsB "'a arbol" "'a bosque"

text ‹Regla de inducción correspondiente a la recursión cruzada:
La regla de inducción sobre árboles y bosques es arbol_bosque.induct:
⟦⋀x b. P2 b ⟹ P1 (Nodo x b);
P2 Vacio;
⋀a b. ⟦P1 a; P2 b⟧ ⟹ P2 (ConsB a b)⟧
⟹ P1 a ∧ P2 b›

thm arbol_bosque.induct

text ‹Ejemplos de definición por recursión cruzada:
· aplana_arbol a) es la lista obtenida aplanando el árbol a.
· (aplana_bosque b) es la lista obtenida aplanando el bosque b.
· (map_arbol f a) es el árbol obtenido aplicando la función f a
todos los nodos del árbol a.
· (map_bosque f b) es el bosque obtenido aplicando la función f a
todos los nodos del bosque b. ›

fun aplana_arbol :: "'a arbol ⇒ 'a list" and
aplana_bosque :: "'a bosque ⇒ 'a list" where
"aplana_arbol (Nodo x b) = x # (aplana_bosque b)"
| "aplana_bosque Vacio = []"
| "aplana_bosque (ConsB a b) = (aplana_arbol a) @ (aplana_bosque b)"

fun map_arbol :: "('a ⇒ 'b) ⇒ 'a arbol ⇒ 'b arbol" and
map_bosque :: "('a ⇒ 'b) ⇒ 'a bosque ⇒ 'b bosque" where
"map_arbol f (Nodo x b) = Nodo (f x) (map_bosque f b)"
| "map_bosque f Vacio = Vacio"
| "map_bosque f (ConsB a b) = ConsB (map_arbol f a) (map_bosque f b)"

text ‹Ejemplo de demostración por inducción cruzada:
Demostrar que:
· aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
· aplana_bosque (map_bosque f b) = map f (aplana_bosque b)›

declare [[names_short]]

― ‹La demostración declarativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by simp
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by simp
also have "… = (f x) # (map f (aplana_bosque b))"
using HI by simp
also have "… = map f (aplana_arbol (Nodo x b))"
by simp
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by simp
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))" by simp
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by simp
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
using HI1 HI2 by simp
also have "… = map f (aplana_bosque (ConsB a b))" by simp
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

― ‹La demostración declarativa detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))"
by (simp only: map_arbol.simps(1))
also have "… = (f x) # (aplana_bosque (map_bosque f b))"
by (simp only: aplana_arbol.simps(1))
also have "… = (f x) # (map f (aplana_bosque b))"
by (simp only: HI)
also have "… = map f (aplana_arbol (Nodo x b))"
by (simp only: list.map aplana_arbol.simps(1))
finally show "aplana_arbol (map_arbol f (Nodo x b)) =
map f (aplana_arbol (Nodo x b))"
by this
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by (simp only: aplana_bosque.simps(1)
map_bosque.simps(1)
list.map)
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))"
by (simp only: map_bosque.simps(2))
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by (simp only: aplana_bosque.simps(2))
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
by (simp only: HI1 HI2)
also have "… = map f (aplana_arbol a @ aplana_bosque b)"
by (simp only: map_append)
also have "… = map f (aplana_bosque (ConsB a b))"
by (simp only: aplana_bosque.simps(2))
finally show "aplana_bosque (map_bosque f (ConsB a b)) =
map f (aplana_bosque (ConsB a b))"
by this
qed

text ‹Comentarios sobre la demostración anterior:
· (induct_tac a and b) indica que el método de demostración es por
inducción cruzada sobre a y b.
· Se generan 3 casos:
1. ⋀a bosque.
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque) ⟹
aplana_arbol (map_arbol (arbol.Nodo a bosque) h) =
map h (aplana_arbol (arbol.Nodo a bosque))
2. aplana_bosque (map_bosque Vacio h) = map h (aplana_bosque Vacio)
3. ⋀arbol bosque.
⟦aplana_arbol (map_arbol arbol h) = map h (aplana_arbol arbol);
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque)⟧
⟹ aplana_bosque (map_bosque (ConsB arbol bosque) h) =
map h (aplana_bosque (ConsB arbol bosque))›

― ‹La demostración automática es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b) simp_all

end
</source>

Razonamiento por casos y por inducci¢n

2020-05-06T17:00:20Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 7: Razonamiento por casos y por inducción›

theory T7_Razonamiento_por_casos_y_por_induccion
imports Main HOL.Parity
begin

text ‹En este tema se amplían los métodos de demostración por casos y
por inducción iniciados en el tema anterior.›

section ‹Razonamiento por distinción de casos›

subsection ‹Distinción de casos booleanos›

text ‹Ejemplo de demostración por distinción de casos booleanos:
Demostrar "¬A ∨ A".›

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof cases
assume "A"
then show "¬A ∨ A" ..
next
assume "¬A"
then show "¬A ∨ A" ..
qed

text ‹Comentarios de la demostración anterior:
· "proof cases" indica que el método de demostración será por
distinción de casos.
· Se generan 2 casos:
1. ?P ⟹ ¬A ∨ A
2. ¬?P ⟹ ¬A ∨ A
donde ?P es una variable sobre las fórmulas.
· (assume "A") indica que se está usando "A" en lugar de la variable
?P.
· "then" indica usando la fórmula anterior.
· ".." indica usando la regla lógica necesaria (las reglas lógicas se
estudiarán en los siguientes temas).
· "next" indica el siguiente caso (se puede observar cómo ha
sustituido ¬?P por ¬A.›

― ‹La demostración aplicativa es›
lemma "¬A ∨ A"
apply cases
apply simp_all
done

― ‹La demostración automática es›
lemma "¬A ∨ A"
by cases simp_all

lemma "¬A ∨ A"
by auto

text ‹Ejemplo de demostración por distinción de casos booleanos con
nombres:
Demostrar "¬A ∨ A".›

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof (cases "A")
case True
then show "¬A ∨ A" ..
next
case False
then show "¬A ∨ A" ..
qed

text ‹Comentarios sobre la demostración anterior:
· (cases "A") indica que la demostración se hará por casos según los
distintos valores de "A".
· Como "A" es una fórmula, sus posibles valores son verdadero o falso.
· "case True" indica que se está suponiendo que A es verdadera. Es
equivalente a "assume A".
· "case False" indica que se está suponiendo que A es falsa. Es
equivalente a "assume ¬A".
· En general,
· el método (cases F) es una abreviatura de la aplicación de la regla
⟦F ⟹ Q; ¬F ⟹ Q⟧ ⟹ Q
· La expresión "case True" es una abreviatura de F.
· La expresión "case False" es una abreviatura de ¬F.
· Ventajas de "cases" con nombre:
· reduce la escritura de la fórmula y
· es independiente del orden de los casos.›

subsection ‹Distinción de casos sobre otros tipos de datos›

text ‹Ejemplo de distinción de casos sobre listas:
Demostrar que la longitud del resto de una lista es la longitud de la
lista menos 1.›

― ‹La demostración estructurada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
assume "xs = []"
then have "length (tl xs) = 0"
by simp
also have "… = 0 - 1"
by simp
also have "… = length xs - 1"
using ‹xs = []›
by simp
finally show "length (tl xs) = length xs - 1"
by this
next
fix y ys
assume "xs = y#ys"
then have "length (tl xs) = length ys"
by simp
also have "… = (1 + length ys) - 1"
by simp
also have "… = length (y#ys) - 1"
by simp
also have "… = length xs - 1"
using ‹xs = y#ys›
by simp
finally show "length (tl xs) = length xs - 1"
by this
qed

text ‹Comentarios sobre la demostración anterior:
· "(cases xs)" indica que la demostración se hará por casos sobre los
posibles valores de xs.
· Como xs es una lista, sus posibles valores son la lista vacía ([]) o
una lista no vacía (de la forma (y#ys)).
· Se generan 2 casos:
1. xs = [] ⟹ length (tl xs) = length xs - 1
2. ⋀a list. xs = a # list ⟹ length (tl xs) = length xs - 1›

― ‹La demostración detallada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
assume "xs = []"
then have "length (tl xs) = 0"
by (simp only: list.sel(2)
list.size(3))
also have "… = 0 - 1"
by (simp only: natural_zero_minus_one)
also have "… = length xs - 1"
using ‹xs = []›
by (simp only: list.size(3))
finally show "length (tl xs) = length xs - 1"
by this
next
fix y ys
assume "xs = y#ys"
then have "length (tl xs) = length ys"
by (simp only: list.sel(3))
also have "… = length (y#ys) - 1"
by (simp only: length_Cons)
also have "… = length xs - 1"
using ‹xs = y#ys›
by (simp only:)
finally show "length (tl xs) = length xs - 1"
by this
qed

― ‹La demostración simplificada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

text ‹Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de
"assume xs =[]".
· "case Cons" es una abreviatura de
"fix y ys assume xs = y#ys"
· ?thesis es una abreviatura de la conclusión del lema.›

― ‹La demostración aplicativa es›
lemma "length (tl xs) = length xs - 1"
apply (cases xs)
apply simp_all
done

― ‹La demostración automática es›
lemma "length (tl xs) = length xs - 1"
by (cases xs) simp_all

text ‹En el siguiente ejemplo vamos a demostrar una propiedad de la
función drop que está definida en la teoría List de forma que
(drop n xs) es la lista obtenida eliminando en xs los n primeros
elementos. Su definición es la siguiente
drop_Nil: "drop n [] = []"
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)" ›

text ‹Ejemplo de análisis de casos:
Demostrar que el resultado de eliminar los n+1 primeros elementos de
xs es el mismo que eliminar los n primeros elementos del resto de xs.›

― ‹La demostración estructurada es›
lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

― ‹La demostración aplicativa es›
lemma "drop (n + 1) xs = drop n (tl xs)"
apply (cases xs)
apply simp_all
done

― ‹La demostración automática es›
lemma "drop (n + 1) xs = drop n (tl xs)"
by (cases xs) simp_all

section ‹Inducción matemática›

text ‹[Principio de inducción matemática]
Para demostrar una propiedad P para todos los números naturales basta
probar que el 0 tiene la propiedad P y que si n tiene la propiedad P,
entonces n+1 también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción matemática está formalizado en
el teorema nat.induct y puede verse con
thm nat.induct
›

text ‹Ejemplo de demostración por inducción: Usaremos el principio de
inducción matemática para demostrar que
1 + 3 + ... + (2n-1) = n^2

Definición. [Suma de los primeros impares]
(suma_impares n) la suma de los n números impares. Por ejemplo,
suma_impares 3 = 9
›

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

value "suma_impares 3"

text ‹ Ejemplo de demostración por inducción matemática:
Demostrar que la suma de los n primeros números impares es n^2.›

― ‹Demostración estructurada del lema anterior por inducción y
razonamiento ecuacional›
lemma "suma_impares n = n * n"
proof (induct n)
show "suma_impares 0 = 0 * 0"
by simp
next
fix n assume HI: "suma_impares n = n * n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n"
using HI by simp
also have "… = n * n + 2 * n + 1"
by simp
also have "… = (Suc n) * (Suc n)"
by simp
finally show "suma_impares (Suc n) = (Suc n) * (Suc n)"
by this
qed

― ‹Demostración del lema anterior con patrones y razonamiento
ecuacional›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0"
by simp
next
fix n
assume HI: "?P n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n"
using HI by simp
also have "… = n * n + 2 * n + 1"
by simp
also have "… = Suc n * Suc n"
by simp
finally show "?P (Suc n)"
by this
qed

text ‹Comentario sobre la demostración anterior:
· Con la expresión
"suma_impares n = n * n" (is "?P n")
se abrevia "suma_impares n = n * n" como "?P n". Por tanto,
"?P 0" es una abreviatura de "suma_impares 0 = 0 * 0"
"?P (Suc n)" es una abreviatura de
"suma_impares (Suc n) = (Suc n) * (Suc n)"
· En general, cualquier fórmula seguida de (is patrón) equipara el
patrón con la fórmula. ›

― ‹La demostración usando patrones es›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume "?P n"
then show "?P (Suc n)" by simp
qed

― ‹La demostración aplicativa es›
lemma "suma_impares n = n * n"
apply (induct n)
apply simp_all
done

― ‹La demostración automática es›
lemma "suma_impares n = n * n"
by (induct n) simp_all

text ‹Ejemplo de definición con existenciales.
Un número natural n es par si existe un natural m tal que n=m+m.›

definition par :: "nat ⇒ bool" where
"par n ≡ ∃m. n=m+m"

text ‹Ejemplo de inducción y existenciales:
Demostrar que para todo número natural n, se verifica que n*(n+1)
es par.›

― ‹Demostración estructurada por inducción›
lemma "par (n*(n+1))"
proof (induct n)
show "par (0*(0+1))"
by (simp add: par_def)
next
fix n
assume "par (n*(n+1))"
then have "∃m. n*(n+1) = m+m"
by (simp add: par_def)
then obtain m where m: "n*(n+1) = m+m"
by (rule exE)
then have "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)"
by simp
then have "∃p. (Suc n)*((Suc n)+1) = p+p"
by (rule exI)
then show "par ((Suc n)*((Suc n)+1))"
by (simp add: par_def)
qed

― ‹Demostración casi detallada por inducción›
lemma "par (n*(n+1))"
proof (induct n)
have "(0::nat) = 0 + 0"
by (simp only: add_0)
then have "∃m. (0::nat) = m + m"
by (rule exI)
then have "par 0"
by (simp only: par_def)
then show "par (0*(0+1))"
by (simp only: mult_0)
next
fix n
assume "par (n*(n+1))"
then have "∃m. n*(n+1) = m+m"
by (simp only: par_def)
then obtain m where m: "n*(n+1) = m+m"
by (rule exE)
then have "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)"
by simp
then have "∃p. (Suc n)*((Suc n)+1) = p+p"
by (rule exI)
then show "par ((Suc n)*((Suc n)+1))"
by (simp only: par_def)
qed

― ‹Demostración aplicativa por inducción›
lemma "par (n*(n+1))"
apply (induct n)
apply (simp add: par_def)
apply (simp add: par_def)
apply arith
done

― ‹Demostración automática›
lemma "par (n*(n+1))"
by (induct n) (auto simp add: par_def, arith)

text ‹En Isabelle puede demostrarse de manera más simple un lema
equivalente usando en lugar de la función "par" la función "even"
definida en la teoría Parity por
even x ⟷ x mod 2 = 0 ›

lemma
fixes n :: "nat"
shows "even (n*(n+1))"
by auto

text ‹Comentarios sobre la demostración anterior:
· Para poder usar la función "even" de la librería Parity es necesario
importar dicha librería. Por ello, antes del inicio de la teoría
aparece
imports Main HOL.Parity
›

text ‹Para completar la demostración basta demostrar la equivalencia de
las funciones "par" y "even".›

lemma "par n = even n"
proof -
have "par n = (∃m. n = m+m)"
by (simp only: par_def)
then show "par n = even n"
(* try *)
by presburger
qed

text ‹Comentarios sobre la demostración anterior:
· "by presburger" indica que se use como método de demostración el
algoritmo de decisión de la aritmética de Presburger.›

― ‹Demostración declarativa›
lemma "par n = even n"
apply (unfold par_def)
apply presburger
done

― ‹Demostración automática›
lemma "par n = even n"
by (simp only: par_def, presburger)

section ‹Recursión general. La función de Ackermann›

text ‹El objetivo de esta sección es mostrar el uso de las definiciones
recursivas generales y sus esquemas de inducción. Como ejemplo se usa
la función de Ackermann (se puede consultar información sobre dicha
función en http://en.wikipedia.org/wiki/Ackermann_function).

Definición. La función de Ackermann se define por
A(m,n) = n+1, si m=0,
A(m-1,1), si m>0 y n=0,
A(m-1,A(m,n-1)), si m>0 y n>0
para todo los números naturales.

La función de Ackermann es recursiva, pero no es primitiva recursiva.›

fun ack :: "nat ⇒ nat ⇒ nat" where
"ack 0 n = n+1"
| "ack (Suc m) 0 = ack m 1"
| "ack (Suc m) (Suc n) = ack m (ack (Suc m) n)"

― ‹Ejemplo de evaluación›
value "ack 2 3" (* devuelve 9 *)

text ‹Esquema de inducción correspondiente a una función:
· Al definir una función recursiva general se genera una regla de
inducción. En la definición anterior, la regla generada es
ack.induct:
⟦⋀n. P 0 n;
⋀m. P m 1 ⟹ P (Suc m) 0;
⋀m n. ⟦P (Suc m) n; P m (ack (Suc m) n)⟧ ⟹ P (Suc m) (Suc n)⟧
⟹ P a b
›

text ‹Ejemplo de demostración por la inducción correspondiente a una
función:
Demostrar que para todos m y n, A(m,n) > n.›

― ‹La demostración detallada es›
lemma "ack m n > n"
proof (induct m n rule: ack.induct)
fix n
show "ack 0 n > n"
by (simp only: ack.simps(1))
next
fix m
assume "ack m 1 > 1"
then show "ack (Suc m) 0 > 0"
by (simp only: ack.simps(2))
next
fix m n
assume "n < ack (Suc m) n"
and "ack (Suc m) n < ack m (ack (Suc m) n)"
then show "Suc n < ack (Suc m) (Suc n)"
by (simp only: ack.simps(3))
qed

text ‹Comentarios sobre la demostración anterior:
· (induct m n rule: ack.induct) indica que el método de demostración
es el esquema de recursión correspondiente a la definición de
(ack m n).
· Se generan 3 casos:
1. ⋀n. n < ack 0 n
2. ⋀m. 1 < ack m 1 ⟹ 0 < ack (Suc m) 0
3. ⋀m n. ⟦n < ack (Suc m) n;
ack (Suc m) n < ack m (ack (Suc m) n)⟧
⟹ Suc n < ack (Suc m) (Suc n)
›

― ‹La demostración automática es›
lemma "ack m n > n"
by (induct m n rule: ack.induct) auto

end
</source>

MediaWiki:Sidebar

2020-04-25T18:26:17Z

Jalonso:

* navigation
** mainpage|mainpage-description
** Temas|Temas
** Ejercicios|Ejercicios
** recentchanges-url|recentchanges
* Ayudas
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX|Ayuda de LaTeX
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX#L%C3%B3gica|Lógica en LaTeX
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX#Conjuntos|Conjuntos en LaTeX
* SEARCH
* TOOLBOX
* LANGUAGES

MediaWiki:Sidebar

2020-04-25T18:25:34Z

Jalonso:

* navigation
** mainpage|mainpage-description
** Ejercicios|Ejercicios
** recentchanges-url|recentchanges
* Ayudas
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX|Ayuda de LaTeX
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX#L%C3%B3gica|Lógica en LaTeX
** https://es.wikipedia.org/wiki/Ayuda:Uso_de_TeX#Conjuntos|Conjuntos en LaTeX
* SEARCH
* TOOLBOX
* LANGUAGES

Razonamiento sobre programas en Isabelle/HOL

2020-04-16T05:20:03Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 6: Razonamiento sobre programas›

theory T6_Razonamiento_sobre_programas
imports Main
begin

text ‹En este tema se demuestra con Isabelle las propiedades de los
programas funcionales de tema 6 http://bit.ly/2Za6YWY

Para cada propiedades se presentan distintos tipos de demostraciones:
automáticas, aplicativas y declarativas.›

section ‹Razonamiento ecuacional›

text ‹-----------------------------------------------------------------
Ejemplo 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 [a,c,d] = 3
--------------------------------------------------------------------›

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

value "longitud [a,c,d] = 3"

text ‹ ---------------------------------------------------------------
Ejemplo 2. Demostrar que
longitud [a,c,d] = 3
------------------------------------------------------------------- ›

lemma "longitud [a,c,d] = 3"
apply simp
done

lemma "longitud [a,c,d] = 3"
by simp

text ‹ ---------------------------------------------------------------
Ejemplo 3. Definir la función
fun intercambia :: 'a × 'b ⇒ 'b × 'a
tal que (intercambia p) es el par obtenido intercambiando las
componentes del par p. Por ejemplo,
intercambia (u,v) = (v,u)
------------------------------------------------------------------ ›

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

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

text ‹La definición de la función intercambia genera una regla de
simplificación
· intercambia.simps: intercambia (x,y) = (y,x)

Se puede ver con
· thm intercambia.simps
›

thm intercambia.simps
(* da intercambia (?x, ?y) = (?y, ?x) *)

text ‹ ---------------------------------------------------------------
Ejemplo 4. (p.6) Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- ›

(* Demostración automática *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by auto

(* Demostración automática 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

(* Demostración automática 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by (simp only: intercambia.simps)

(* Demostración aplicativa *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
apply (simp only: intercambia.simps)
done

(* Demostración declarativa 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by simp
also have "… = (x,y)"
by simp
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

(* Demostración detallada *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by (simp only: intercambia.simps)
also have "… = (x,y)"
by (simp only: intercambia.simps)
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

text ‹Notas sobre el lenguaje: En la demostración anterior se ha usado
· "proof" para iniciar la prueba,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "by (simp only: intercambia.simps)" para indicar que sólo se usa
como regla de escritura la correspondiente a la definición de
intercambia,
· "also" para encadenar pasos ecuacionales,
· "…" para representar la derecha de la igualdad anterior en un
razonamiento ecuacional,
· "finally" para indicar el último pasa de un razonamiento ecuacional,
· "show" para establecer la conclusión.
· "by simp" para indicar el método de demostración por simplificación y
· "qed" para terminar la pruebas.›

text ‹---------------------------------------------------------------
Ejemplo 5. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [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 ‹ ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- ›

(* La demostración automática es *)
lemma "inversa [x] = [x]"
by simp

(* La demostración aplicativa es *)
lemma "inversa [x] = [x]"
apply simp
done

text ‹En la demostración anterior se usaron las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
Vamos a explicitar su aplicación.
›

find_theorems
find_theorems "_ @ _ = _"
find_theorems "[] @ _ = _"

(* La demostración aplicativa detallada es *)
lemma "inversa [x] = [x]"
apply (simp only: inversa.simps(2)) (* inversa [] @ [x] = [x] *)
apply (simp only: inversa.simps(1)) (* [] @ [x] = [x] *)
apply (simp only: append_Nil) (* No subgoals! *)
done

(* La demostración declarativa simplificada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "… = (inversa []) @ [x]" by simp
also have "… = [] @ [x]" by simp
also have "… = [x]" by simp
finally show "inversa [x] = [x]" by simp
qed

(* La demostración declarativa detallada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])"
by simp
also have "… = (inversa []) @ [x]"
by (simp only: inversa.simps(2))
also have "… = [] @ [x]"
by (simp only: inversa.simps(1))
also have "… = [x]"
by (simp only: append_Nil)
finally show "inversa [x] = [x]" by simp
qed

section ‹Razonamiento por inducción sobre los naturales ›

text ‹[Principio de inducción sobre los naturales] Para demostrar una
propiedad P para todos los números naturales basta probar que el 0
tiene la propiedad P y que si n tiene la propiedad P, entonces n+1
también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción sobre los naturales está
formalizado en el teorema nat.induct y puede verse con
thm nat.induct
›

thm nat.induct

text ‹---------------------------------------------------------------
Ejemplo 7. 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 ‹ ---------------------------------------------------------------
Ejemplo 8. (p. 18) Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* 1. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* No subgoals *)
done

(* La demostración aplicativa con simp_all es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp_all (* No subgoals *)
done

(* La demostración automática es *)
lemma "longitud (repite n x) = n"
by (induct n) simp_all

(* La demostración declarativa es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0"
by simp
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by simp
also have "… = 1 + longitud (repite n x)"
by simp
also have "… = 1 + n"
using HI by simp
finally show "longitud (repite (Suc n) x) = Suc n"
by simp
qed

text ‹Comentarios sobre la demostración anterior:
· A la derecha de proof se indica el método de la demostración.
· (induct n) indica que la demostración se hará por inducción en n.
· Se generan dos subobjetivos correspondientes a la base y el paso de
inducción:
1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n
donde ⋀n se lee "para todo n".
· "next" indica el siguiente subobjetivo.
· "fix n" indica "sea n un número natural cualquiera"
· assume HI: "longitud (repite n x) = n" indica «supongamos que
"longitud (repite n x) = n" y sea HI la etiqueta de este supuesto».
· "using HI" usando la propiedad etiquetada con HI. ›

(* La demostración declarativa detallada es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0"
by (simp only: repite.simps(1)
longitud.simps(1))
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by (simp only: repite.simps(2))
also have "… = 1 + longitud (repite n x)"
by (simp only: longitud.simps(2))
also have "… = 1 + n"
by (simp only: HI)
also have "… = Suc n"
find_theorems "Suc _ = _ + _"
by (simp only: Suc_eq_plus1_left)
finally show "longitud (repite (Suc n) x) = Suc n"
by this
qed

section ‹Razonamiento por inducción sobre listas ›

text ‹Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a
una lista que tiene la propiedad se obtiene otra lista que también
tiene la propiedad.

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct
⟦P [];
⋀x xs. P xs ⟹ P (x#xs)⟧
⟹ P xs
›

thm list.induct

text ‹---------------------------------------------------------------
Ejemplo 9. 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 ‹ ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs) (* 1. conc [] (conc ys zs) = conc (conc [] ys) zs
2. ⋀a xs.
conc xs (conc ys zs) =
conc (conc xs ys) zs ⟹
conc (a # xs) (conc ys zs) =
conc (conc (a # xs) ys) zs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs"
by simp
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))"
by simp
also have "… = x # (conc (conc xs ys) zs)"
using HI by simp
also have "… = conc (conc (x # xs) ys) zs"
by simp
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs"
by (simp only: conc.simps(1))
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))"
by (simp only: conc.simps(2))
also have "… = x # (conc (conc xs ys) zs)"
using HI by (simp only:)
also have "… = conc (conc (x # xs) ys) zs"
by (simp only: conc.simps(2))
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by this
qed

text ‹---------------------------------------------------------------
Ejemplo 11. Refutar que
conc xs ys = conc ys xs
------------------------------------------------------------------- ›

lemma "conc xs ys = conc ys xs"
quickcheck
oops

text ‹ Encuentra el contraejemplo,
xs = [a2]
ys = [a1] ›

text ‹---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc xs [] = xs"
apply (induct xs) (* 1. conc [] [] = []
2. ⋀a xs.
conc xs [] = xs ⟹
conc (a # xs) [] = a # xs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs [] = xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x xs
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by simp
also have "… = x # xs"
using HI by simp
finally show "conc (x # xs) [] = x # xs"
by simp
qed

(* declare [[show_types]] *)

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x :: "'a" and xs :: "'a list"
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by simp
also have "… = x # xs"
using HI by simp
finally show "conc (x # xs) [] = x # xs"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []"
by (simp only: conc.simps(1))
next
fix x :: "'a" and xs :: "'a list"
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by (simp only: conc.simps(2))
also have "… = x # xs"
using HI by (simp only:)
finally show "conc (x # xs) [] = x # xs"
by this
qed

text ‹---------------------------------------------------------------
Ejemplo 13. (p. 30) Demostrar que
longitud (conc xs ys) = longitud xs + longitud ys
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs) (* 1. longitud (conc [] ys) =
longitud [] + longitud ys
2. ⋀a xs.
longitud (conc xs ys) =
longitud xs + longitud ys ⟹
longitud (conc (a # xs) ys) =
longitud (a # xs) + longitud ys *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys" by simp
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by simp
also have "… = 1 + longitud (conc xs ys)"
by simp
also have "… = 1 + longitud xs + longitud ys"
using HI by simp
also have "… = longitud (x # xs) + longitud ys"
by simp
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys"
by (simp only: conc.simps(1)
longitud.simps(1))
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by (simp only: conc.simps(2))
also have "… = 1 + longitud (conc xs ys)"
by (simp only: longitud.simps(2))
also have "… = 1 + longitud xs + longitud ys"
using HI by (simp only:)
also have "… = longitud (x # xs) + longitud ys"
by (simp only: longitud.simps(2))
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys"
by this
qed

section ‹Inducción correspondiente a la definición recursiva ›

text ‹---------------------------------------------------------------
Ejemplo 14. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [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 ‹---------------------------------------------------------------
Ejemplo 15. 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 ‹
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". ›

thm coge.induct

text ‹---------------------------------------------------------------
Ejemplo 16. (p. 35) Demostrar que
conc (coge n xs) (elimina n xs) = xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
(* 1. ⋀n. conc (coge n []) (elimina n []) = []
2. ⋀v va. conc (coge 0 (v # va)) (elimina 0 (v # va)) =
v # va
3. ⋀n x xs. conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x # xs))
(elimina (Suc n) (x # xs)) =
x # xs *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) simp_all

(* La demostración declarativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []"
by simp
next
fix x :: "'a" and xs :: "'a list"
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs"
by simp
next
fix n and x :: "'a" and xs :: "'a list"
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)"
by simp
also have "… = x#(conc (coge n xs) (elimina n xs))"
by simp
also have "… = x#xs"
using HI by simp
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by simp
qed

text ‹Comentario sobre la demostración anterior:
· (induct rule: coge.induct) indica que el método de demostración es
por el esquema de inducción correspondiente a la definición de la
función coge.
· Se generan 3 subobjetivos:
· 1. ⋀n. conc (coge n []) (elimina n []) = []
· 2. ⋀x xs. conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs
· 3. ⋀n x xs.
conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) = x#xs
›

(* La demostración declarativa detallada es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []"
by (simp only: coge.simps(1)
elimina.simps(1)
conc.simps(1))
next
fix x :: "'a" and xs :: "'a list"
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs"
by (simp only: coge.simps(2)
elimina.simps(2)
conc.simps(1))
next
fix n and x :: "'a" and xs :: "'a list"
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)"
by (simp only: coge.simps(3)
elimina.simps(3))
also have "… = x#(conc (coge n xs) (elimina n xs))"
by (simp only: conc.simps(2))
also have "… = x#xs"
using HI by (simp only:)
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by this
qed

section ‹Razonamiento por casos ›

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

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

value "esVacia [] = True"
value "esVacia [a] = False"

text ‹---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
(* 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
2. ⋀a list. xs = a # list ⟹
esVacia xs = esVacia (conc xs xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) simp_all

(* La demostración declarativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)"
by simp
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)"
by simp
qed

text ‹Comentarios sobre la demostración anterior:
· "(cases xs)" es el método de demostración por casos según xs.
· Se generan dos subobjetivos correspondientes a los dos
constructores de listas:
· 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
· 2. ⋀y ys. xs = y#ys ⟹ esVacia xs = esVacia (conc xs xs)
· "then" indica "usando la propiedad anterior"
›

(* La demostración declarativa detallada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)"
by (simp only: conc.simps(1))
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)"
by (simp only: esVacia.simps(2)
conc.simps(2))
qed

(* La demostración declarativa simplificada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show "esVacia xs = esVacia (conc xs xs)"
by simp
next
case Cons
then show "esVacia xs = esVacia (conc xs xs)"
by simp
qed

text ‹
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de "assume xs = []"
· "case Cons" es una abreviatura de "fix y ys assume xs = y#ys"›

(* La demostración con el patrón sugerido es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case (Cons x xs)
then show ?thesis by simp
qed

section ‹Heurística de generalización ›

text ‹---------------------------------------------------------------
Ejemplo 19. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [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)"

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

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

text ‹Lema. [Ejemplo de equivalencia entre las definiciones]
La inversa de [a,b,c] es lo mismo calculada con la primera definición
que con la segunda.›

lemma "inversaAc [a,b,c] = inversa [a,b,c]"
by (simp add: inversaAc_def)

text ‹Nota. [Ejemplo fallido de demostración por inducción]
El siguiente intento de demostrar que para cualquier lista xs, se
tiene que "inversaAc xs = inversa xs" falla.›

lemma "inversaAc xs = inversa xs"
proof (induct xs)
show "inversaAc [] = inversa []"
by (simp add: inversaAc_def)
next
fix a :: "'b" and xs :: "'b list"
assume HI: "inversaAc xs = inversa xs"
have "inversaAc (a#xs) = inversaAcAux (a#xs) []"
by (simp add: inversaAc_def)
also have "… = inversaAcAux xs [a]"
by simp
also have "… = inversa (a#xs)"
(* Problema: la hipótesis de inducción no es aplicable. *)
oops

text ‹Nota. [Heurística de generalización]
Cuando se use demostración estructural, cuantificar universalmente las
variables libres (o, equivalentemente, considerar las variables libres
como variables arbitrarias).

Lema. [Lema con generalización]
Para toda lista ys se tiene
inversaAcAux xs ys = (inversa xs) @ ys
›

text ‹---------------------------------------------------------------
Ejemplo 20. (p. 44) Demostrar que
inversaAcAux xs ys = (inversa xs) @ ys
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
(* 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
2. ⋀a xs ys.
(⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) simp_all

(* La demostración declarativa es *)
lemma
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = (inversa [])@ys"
by simp
next
fix a :: "'b" and xs :: "'b list"
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)"
by simp
also have "… = inversa xs@(a#ys)"
using HI by simp
also have "… = inversa (a#xs)@ys" using [[simp_trace]]
by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
by simp
qed
qed

text ‹Comentarios sobre la demostración anterior:
· "(induct xs arbitrary: ys)" es el método de demostración por
inducción sobre xs usando ys como variable arbitraria.
· Se generan dos subobjetivos:
· 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
· 2. ⋀a xs ys. (⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys
· Dentro de una demostración se pueden incluir otras demostraciones.
· Para demostrar la propiedad universal "⋀ys. P(ys)" se elige una
lista arbitraria (con "fix ys") y se demuestra "P(ys)". ›

text ‹Nota. En el paso "inversa xs@(a#ys) = inversa (a#xs)@ys" se usan
lemas de la teoría List. Se puede observar, insertano
using [[simp_trace]]
entre la igualdad y by simp, que los lemas usados son
· List.append_simps_1: []@ys = ys
· List.append_simps_2: (x#xs)@ys = x#(xs@ys)
· List.append_assoc: (xs @ ys) @ zs = xs @ (ys @ zs)
Las dos primeras son las ecuaciones de la definición de append.

En la siguiente demostración se detallan los lemas utilizados.
›

― ‹Demostración aplicativa›
lemma "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
apply (simp only: inversa.simps(2))
(* inversa xs @ (a # ys) = (inversa xs @ [a]) @ ys*)
apply (simp only: append_assoc)
(* inversa xs @ (a # ys) = inversa xs @ ([a] @ ys) *)
apply (simp only: append.simps(2))
(* inversa xs @ (a # ys) = inversa xs @ (a # ([] @ ys)) *)
apply (simp only: append.simps(1))
(* *)
done

― ‹Demostración declarativa detallada del lema auxiliar›
lemma auxiliar: "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
proof -
have "(inversa xs)@(a#ys) = (inversa xs)@(a#([]@ys))"
by (simp only: append.simps(1))
also have "… = (inversa xs)@([a]@ys)"
by (simp only: append.simps(2))
also have "… = ((inversa xs)@[a])@ys"
by (simp only: append_assoc)
also have "… = (inversa (a#xs))@ys"
by (simp only: inversa.simps(2))
finally show ?thesis
by this
qed

(* La demostración declarativa detallada es *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
fix ys :: "'b list"
show "inversaAcAux [] ys = (inversa [])@ys"
by (simp only: inversaAcAux.simps(1)
inversa.simps(1)
append.simps(1))
next
fix a :: "'b" and xs :: "'b list"
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)"
by (simp only: inversaAcAux.simps(2))
also have "… = inversa xs@(a#ys)"
using HI by (simp only:)
also have "… = inversa (a#xs)@ys"
by (rule auxiliar)
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
by this
qed
qed

text ‹---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
corollary "inversaAc xs = inversa xs"
apply (simp add: inversaAcAux_es_inversa inversaAc_def)
done

(* La demostración automática es *)
corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa inversaAc_def)

text ‹Comentario de la demostración anterior:
· "(simp add: inversaAcAux_es_inversa inversaAc_def)" es el método de
demostración por simplificación usando como regla de simplificación
las propiedades inversaAcAux_es_inversa e inversaAc_def. ›

section ‹Demostración por inducción para funciones de orden superior ›

text ‹ ---------------------------------------------------------------
Ejemplo 22. 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 ‹---------------------------------------------------------------
Ejemplo 23. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3::nat,2,5] = [6,4,10]
map ((*) 2) [3::nat,2,5] = [6,4,10]
map ((+) 2) [3::nat,2,5] = [5,4,7]
------------------------------------------------------------------ ›

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]"
value "map ((*) 2) [3::nat,2,5] = [6,4,10]"
value "map ((+) 2) [3::nat,2,5] = [5,4,7]"

text ‹---------------------------------------------------------------
Ejemplo 24. (p. 45) Demostrar que
sum (map ((*) 2) xs) = 2 * (sum xs)
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
apply (induct xs)
(* 1. sum (map (( * ) 2) []) = 2 * sum []
2. ⋀a xs. sum (map (( * ) 2) xs) = 2 * sum xs ⟹
sum (map (( * ) 2) (a # xs)) = 2 * sum (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map ((*) 2) []) = 2 * (sum [])" by simp
next
fix a xs
assume HI: "sum (map ((*) 2) xs) = 2 * (sum xs)"
have "sum (map ((*) 2) (a#xs)) = sum ((2*a)#(map ((*) 2) xs))"
by simp
also have "… = 2*a + sum (map ((*) 2) xs)"
by simp
also have "… = 2*a + 2*(sum xs)"
using HI by simp
also have "… = 2*(a + sum xs)"
by simp
also have "… = 2*(sum (a#xs))"
by simp
finally show "sum (map ((*) 2) (a#xs)) = 2*(sum (a#xs))"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map ((*) 2) []) = 2 * (sum [])"
by (simp only: map.simps(1)
sum.simps(1))
next
fix a xs
assume HI: "sum (map ((*) 2) xs) = 2 * (sum xs)"
have "sum (map ((*) 2) (a#xs)) = sum ((2*a)#(map ((*) 2) xs))"
by (simp only: map.simps(2))
also have "… = 2*a + sum (map ((*) 2) xs)"
by (simp only: sum.simps(2))
also have "… = 2*a + 2*(sum xs)"
using HI by (simp only:)
also have "… = 2*(a + sum xs)"
find_theorems "_ * (_ + _)"
by (simp only: add_mult_distrib2)
also have "… = 2*(sum (a#xs))"
by (simp only: sum.simps(2))
finally show "sum (map ((*) 2) (a#xs)) = 2*(sum (a#xs))"
by this
qed

text ‹ ---------------------------------------------------------------
Ejemplo 25. (p. 48) Demostrar que
longitud (map f xs) = longitud xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
(* 1. longitud (map f []) = longitud []
2. ⋀a xs. longitud (map f xs) = longitud xs ⟹
longitud (map f (a # xs)) = longitud (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []"
by simp
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))"
by simp
also have "… = 1 + longitud (map f xs)"
by simp
also have "… = 1 + longitud xs"
using HI by simp
also have "… = longitud (a#xs)"
by simp
finally show "longitud (map f (a#xs)) = longitud (a#xs)"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []"
by (simp only: map.simps(1)
longitud.simps(1))
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))"
by (simp only: map.simps(2))
also have "… = 1 + longitud (map f xs)"
by (simp only: longitud.simps(2))
also have "… = 1 + longitud xs"
using HI by (simp only:)
also have "… = longitud (a#xs)"
by (simp only: longitud.simps(2))
finally show "longitud (map f (a#xs)) = longitud (a#xs)"
by this
qed

section ‹Referencias›

text ‹
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms".
· S. Thompson. "Haskell: the Craft of Functional Programming, 3rd
Edition. Cap. 8 "Reasoning about programms".
· L. Paulson. "ML for the Working Programmer, 2nd Edition". Cap. 6.
"Reasoning about functional programs".
›

end
</source>

Razonamiento sobre programas en Isabelle/HOL

2020-04-16T05:17:29Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 6: Razonamiento sobre programas›

theory T6_Razonamiento_sobre_programas
imports Main
begin

text ‹En este tema se demuestra con Isabelle las propiedades de los
programas funcionales de tema 6 http://bit.ly/2Za6YWY

Para cada propiedades se presentan distintos tipos de demostraciones:
automáticas, aplicativas y declarativas.›

(* declare [[names_short]] *)

section ‹Razonamiento ecuacional›

text ‹-----------------------------------------------------------------
Ejemplo 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 [a,c,d] = 3
--------------------------------------------------------------------›

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

value "longitud [a,c,d] = 3"

text ‹ ---------------------------------------------------------------
Ejemplo 2. Demostrar que
longitud [a,c,d] = 3
------------------------------------------------------------------- ›

lemma "longitud [a,c,d] = 3"
apply simp
done

lemma "longitud [a,c,d] = 3"
by simp

text ‹ ---------------------------------------------------------------
Ejemplo 3. Definir la función
fun intercambia :: 'a × 'b ⇒ 'b × 'a
tal que (intercambia p) es el par obtenido intercambiando las
componentes del par p. Por ejemplo,
intercambia (u,v) = (v,u)
------------------------------------------------------------------ ›

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

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

text ‹La definición de la función intercambia genera una regla de
simplificación
· intercambia.simps: intercambia (x,y) = (y,x)

Se puede ver con
· thm intercambia.simps
›

thm intercambia.simps
(* da intercambia (?x, ?y) = (?y, ?x) *)

text ‹ ---------------------------------------------------------------
Ejemplo 4. (p.6) Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- ›

(* Demostración automática *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by auto

(* Demostración automática 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

(* Demostración automática 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by (simp only: intercambia.simps)

(* Demostración aplicativa *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
apply (simp only: intercambia.simps)
done

(* Demostración declarativa 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by simp
also have "… = (x,y)"
by simp
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

(* Demostración detallada *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by (simp only: intercambia.simps)
also have "… = (x,y)"
by (simp only: intercambia.simps)
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

text ‹Notas sobre el lenguaje: En la demostración anterior se ha usado
· "proof" para iniciar la prueba,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "by (simp only: intercambia.simps)" para indicar que sólo se usa
como regla de escritura la correspondiente a la definición de
intercambia,
· "also" para encadenar pasos ecuacionales,
· "…" para representar la derecha de la igualdad anterior en un
razonamiento ecuacional,
· "finally" para indicar el último pasa de un razonamiento ecuacional,
· "show" para establecer la conclusión.
· "by simp" para indicar el método de demostración por simplificación y
· "qed" para terminar la pruebas.›

text ‹---------------------------------------------------------------
Ejemplo 5. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [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 ‹ ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- ›

(* La demostración automática es *)
lemma "inversa [x] = [x]"
by simp

(* La demostración aplicativa es *)
lemma "inversa [x] = [x]"
apply simp
done

text ‹En la demostración anterior se usaron las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
Vamos a explicitar su aplicación.
›

find_theorems
find_theorems "_ @ _ = _"
find_theorems "[] @ _ = _"

(* La demostración aplicativa detallada es *)
lemma "inversa [x] = [x]"
apply (simp only: inversa.simps(2)) (* inversa [] @ [x] = [x] *)
apply (simp only: inversa.simps(1)) (* [] @ [x] = [x] *)
apply (simp only: append_Nil) (* No subgoals! *)
done

(* La demostración declarativa simplificada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "… = (inversa []) @ [x]" by simp
also have "… = [] @ [x]" by simp
also have "… = [x]" by simp
finally show "inversa [x] = [x]" by simp
qed

(* La demostración declarativa detallada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])"
by simp
also have "… = (inversa []) @ [x]"
by (simp only: inversa.simps(2))
also have "… = [] @ [x]"
by (simp only: inversa.simps(1))
also have "… = [x]"
by (simp only: append_Nil)
finally show "inversa [x] = [x]" by simp
qed

section ‹Razonamiento por inducción sobre los naturales ›

text ‹[Principio de inducción sobre los naturales] Para demostrar una
propiedad P para todos los números naturales basta probar que el 0
tiene la propiedad P y que si n tiene la propiedad P, entonces n+1
también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción sobre los naturales está
formalizado en el teorema nat.induct y puede verse con
thm nat.induct
›

thm nat.induct

text ‹---------------------------------------------------------------
Ejemplo 7. 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 ‹ ---------------------------------------------------------------
Ejemplo 8. (p. 18) Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* 1. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* No subgoals *)
done

(* La demostración aplicativa con simp_all es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp_all (* No subgoals *)
done

(* La demostración automática es *)
lemma "longitud (repite n x) = n"
by (induct n) simp_all

(* La demostración declarativa es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0"
by simp
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by simp
also have "… = 1 + longitud (repite n x)"
by simp
also have "… = 1 + n"
using HI by simp
finally show "longitud (repite (Suc n) x) = Suc n"
by simp
qed

text ‹Comentarios sobre la demostración anterior:
· A la derecha de proof se indica el método de la demostración.
· (induct n) indica que la demostración se hará por inducción en n.
· Se generan dos subobjetivos correspondientes a la base y el paso de
inducción:
1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n
donde ⋀n se lee "para todo n".
· "next" indica el siguiente subobjetivo.
· "fix n" indica "sea n un número natural cualquiera"
· assume HI: "longitud (repite n x) = n" indica «supongamos que
"longitud (repite n x) = n" y sea HI la etiqueta de este supuesto».
· "using HI" usando la propiedad etiquetada con HI. ›

(* La demostración declarativa detallada es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0"
by (simp only: repite.simps(1)
longitud.simps(1))
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by (simp only: repite.simps(2))
also have "… = 1 + longitud (repite n x)"
by (simp only: longitud.simps(2))
also have "… = 1 + n"
by (simp only: HI)
also have "… = Suc n"
find_theorems "Suc _ = _ + _"
by (simp only: Suc_eq_plus1_left)
finally show "longitud (repite (Suc n) x) = Suc n"
by this
qed

section ‹Razonamiento por inducción sobre listas ›

text ‹Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a
una lista que tiene la propiedad se obtiene otra lista que también
tiene la propiedad.

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct
⟦P [];
⋀x xs. P xs ⟹ P (x#xs)⟧
⟹ P xs
›

thm list.induct

text ‹---------------------------------------------------------------
Ejemplo 9. 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 ‹ ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs) (* 1. conc [] (conc ys zs) = conc (conc [] ys) zs
2. ⋀a xs.
conc xs (conc ys zs) =
conc (conc xs ys) zs ⟹
conc (a # xs) (conc ys zs) =
conc (conc (a # xs) ys) zs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs"
by simp
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))"
by simp
also have "… = x # (conc (conc xs ys) zs)"
using HI by simp
also have "… = conc (conc (x # xs) ys) zs"
by simp
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs"
by (simp only: conc.simps(1))
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))"
by (simp only: conc.simps(2))
also have "… = x # (conc (conc xs ys) zs)"
using HI by (simp only:)
also have "… = conc (conc (x # xs) ys) zs"
by (simp only: conc.simps(2))
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by this
qed

text ‹---------------------------------------------------------------
Ejemplo 11. Refutar que
conc xs ys = conc ys xs
------------------------------------------------------------------- ›

lemma "conc xs ys = conc ys xs"
quickcheck
oops

text ‹ Encuentra el contraejemplo,
xs = [a2]
ys = [a1] ›

text ‹---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc xs [] = xs"
apply (induct xs) (* 1. conc [] [] = []
2. ⋀a xs.
conc xs [] = xs ⟹
conc (a # xs) [] = a # xs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs [] = xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x xs
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by simp
also have "… = x # xs"
using HI by simp
finally show "conc (x # xs) [] = x # xs"
by simp
qed

(* declare [[show_types]] *)

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x :: "'a" and xs :: "'a list"
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by simp
also have "… = x # xs"
using HI by simp
finally show "conc (x # xs) [] = x # xs"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []"
by (simp only: conc.simps(1))
next
fix x :: "'a" and xs :: "'a list"
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])"
by (simp only: conc.simps(2))
also have "… = x # xs"
using HI by (simp only:)
finally show "conc (x # xs) [] = x # xs"
by this
qed

text ‹---------------------------------------------------------------
Ejemplo 13. (p. 30) Demostrar que
longitud (conc xs ys) = longitud xs + longitud ys
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs) (* 1. longitud (conc [] ys) =
longitud [] + longitud ys
2. ⋀a xs.
longitud (conc xs ys) =
longitud xs + longitud ys ⟹
longitud (conc (a # xs) ys) =
longitud (a # xs) + longitud ys *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys" by simp
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by simp
also have "… = 1 + longitud (conc xs ys)"
by simp
also have "… = 1 + longitud xs + longitud ys"
using HI by simp
also have "… = longitud (x # xs) + longitud ys"
by simp
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys"
by (simp only: conc.simps(1)
longitud.simps(1))
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by (simp only: conc.simps(2))
also have "… = 1 + longitud (conc xs ys)"
by (simp only: longitud.simps(2))
also have "… = 1 + longitud xs + longitud ys"
using HI by (simp only:)
also have "… = longitud (x # xs) + longitud ys"
by (simp only: longitud.simps(2))
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys"
by this
qed

section ‹Inducción correspondiente a la definición recursiva ›

text ‹---------------------------------------------------------------
Ejemplo 14. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [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 ‹---------------------------------------------------------------
Ejemplo 15. 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 ‹
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". ›

thm coge.induct

text ‹---------------------------------------------------------------
Ejemplo 16. (p. 35) Demostrar que
conc (coge n xs) (elimina n xs) = xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
(* 1. ⋀n. conc (coge n []) (elimina n []) = []
2. ⋀v va. conc (coge 0 (v # va)) (elimina 0 (v # va)) =
v # va
3. ⋀n x xs. conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x # xs))
(elimina (Suc n) (x # xs)) =
x # xs *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) simp_all

(* La demostración declarativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []"
by simp
next
fix x :: "'a" and xs :: "'a list"
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs"
by simp
next
fix n and x :: "'a" and xs :: "'a list"
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)"
by simp
also have "… = x#(conc (coge n xs) (elimina n xs))"
by simp
also have "… = x#xs"
using HI by simp
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by simp
qed

text ‹Comentario sobre la demostración anterior:
· (induct rule: coge.induct) indica que el método de demostración es
por el esquema de inducción correspondiente a la definición de la
función coge.
· Se generan 3 subobjetivos:
· 1. ⋀n. conc (coge n []) (elimina n []) = []
· 2. ⋀x xs. conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs
· 3. ⋀n x xs.
conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) = x#xs
›

(* La demostración declarativa detallada es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []"
by (simp only: coge.simps(1)
elimina.simps(1)
conc.simps(1))
next
fix x :: "'a" and xs :: "'a list"
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs"
by (simp only: coge.simps(2)
elimina.simps(2)
conc.simps(1))
next
fix n and x :: "'a" and xs :: "'a list"
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)"
by (simp only: coge.simps(3)
elimina.simps(3))
also have "… = x#(conc (coge n xs) (elimina n xs))"
by (simp only: conc.simps(2))
also have "… = x#xs"
using HI by (simp only:)
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by this
qed

section ‹Razonamiento por casos ›

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

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

value "esVacia [] = True"
value "esVacia [a] = False"

text ‹---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
(* 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
2. ⋀a list. xs = a # list ⟹
esVacia xs = esVacia (conc xs xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) simp_all

(* La demostración declarativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)"
by simp
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)"
by simp
qed

text ‹Comentarios sobre la demostración anterior:
· "(cases xs)" es el método de demostración por casos según xs.
· Se generan dos subobjetivos correspondientes a los dos
constructores de listas:
· 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
· 2. ⋀y ys. xs = y#ys ⟹ esVacia xs = esVacia (conc xs xs)
· "then" indica "usando la propiedad anterior"
›

(* La demostración declarativa detallada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)"
by (simp only: conc.simps(1))
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)"
by (simp only: esVacia.simps(2)
conc.simps(2))
qed

(* La demostración declarativa simplificada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show "esVacia xs = esVacia (conc xs xs)"
by simp
next
case Cons
then show "esVacia xs = esVacia (conc xs xs)"
by simp
qed

text ‹
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de "assume xs = []"
· "case Cons" es una abreviatura de "fix y ys assume xs = y#ys"›

(* La demostración con el patrón sugerido es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case (Cons x xs)
then show ?thesis by simp
qed

section ‹Heurística de generalización ›

text ‹---------------------------------------------------------------
Ejemplo 19. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [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)"

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

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

text ‹Lema. [Ejemplo de equivalencia entre las definiciones]
La inversa de [a,b,c] es lo mismo calculada con la primera definición
que con la segunda.›

lemma "inversaAc [a,b,c] = inversa [a,b,c]"
by (simp add: inversaAc_def)

text ‹Nota. [Ejemplo fallido de demostración por inducción]
El siguiente intento de demostrar que para cualquier lista xs, se
tiene que "inversaAc xs = inversa xs" falla.›

lemma "inversaAc xs = inversa xs"
proof (induct xs)
show "inversaAc [] = inversa []"
by (simp add: inversaAc_def)
next
fix a :: "'b" and xs :: "'b list"
assume HI: "inversaAc xs = inversa xs"
have "inversaAc (a#xs) = inversaAcAux (a#xs) []"
by (simp add: inversaAc_def)
also have "… = inversaAcAux xs [a]"
by simp
also have "… = inversa (a#xs)"
(* Problema: la hipótesis de inducción no es aplicable. *)
oops

text ‹Nota. [Heurística de generalización]
Cuando se use demostración estructural, cuantificar universalmente las
variables libres (o, equivalentemente, considerar las variables libres
como variables arbitrarias).

Lema. [Lema con generalización]
Para toda lista ys se tiene
inversaAcAux xs ys = (inversa xs) @ ys
›

text ‹---------------------------------------------------------------
Ejemplo 20. (p. 44) Demostrar que
inversaAcAux xs ys = (inversa xs) @ ys
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
(* 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
2. ⋀a xs ys.
(⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) simp_all

(* La demostración declarativa es *)
lemma
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = (inversa [])@ys"
by simp
next
fix a :: "'b" and xs :: "'b list"
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)"
by simp
also have "… = inversa xs@(a#ys)"
using HI by simp
also have "… = inversa (a#xs)@ys" using [[simp_trace]]
by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
by simp
qed
qed

text ‹Comentarios sobre la demostración anterior:
· "(induct xs arbitrary: ys)" es el método de demostración por
inducción sobre xs usando ys como variable arbitraria.
· Se generan dos subobjetivos:
· 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
· 2. ⋀a xs ys. (⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys
· Dentro de una demostración se pueden incluir otras demostraciones.
· Para demostrar la propiedad universal "⋀ys. P(ys)" se elige una
lista arbitraria (con "fix ys") y se demuestra "P(ys)". ›

text ‹Nota. En el paso "inversa xs@(a#ys) = inversa (a#xs)@ys" se usan
lemas de la teoría List. Se puede observar, insertano
using [[simp_trace]]
entre la igualdad y by simp, que los lemas usados son
· List.append_simps_1: []@ys = ys
· List.append_simps_2: (x#xs)@ys = x#(xs@ys)
· List.append_assoc: (xs @ ys) @ zs = xs @ (ys @ zs)
Las dos primeras son las ecuaciones de la definición de append.

En la siguiente demostración se detallan los lemas utilizados.
›

― ‹Demostración aplicativa›
lemma "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
apply (simp only: inversa.simps(2))
(* inversa xs @ (a # ys) = (inversa xs @ [a]) @ ys*)
apply (simp only: append_assoc)
(* inversa xs @ (a # ys) = inversa xs @ ([a] @ ys) *)
apply (simp only: append.simps(2))
(* inversa xs @ (a # ys) = inversa xs @ (a # ([] @ ys)) *)
apply (simp only: append.simps(1))
(* *)
done

― ‹Demostración declarativa detallada del lema auxiliar›
lemma auxiliar: "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
proof -
have "(inversa xs)@(a#ys) = (inversa xs)@(a#([]@ys))"
by (simp only: append.simps(1))
also have "… = (inversa xs)@([a]@ys)"
by (simp only: append.simps(2))
also have "… = ((inversa xs)@[a])@ys"
by (simp only: append_assoc)
also have "… = (inversa (a#xs))@ys"
by (simp only: inversa.simps(2))
finally show ?thesis
by this
qed

(* La demostración declarativa detallada es *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
fix ys :: "'b list"
show "inversaAcAux [] ys = (inversa [])@ys"
by (simp only: inversaAcAux.simps(1)
inversa.simps(1)
append.simps(1))
next
fix a :: "'b" and xs :: "'b list"
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)"
by (simp only: inversaAcAux.simps(2))
also have "… = inversa xs@(a#ys)"
using HI by (simp only:)
also have "… = inversa (a#xs)@ys"
by (rule auxiliar)
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
by this
qed
qed

text ‹---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
corollary "inversaAc xs = inversa xs"
apply (simp add: inversaAcAux_es_inversa inversaAc_def)
done

(* La demostración automática es *)
corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa inversaAc_def)

text ‹Comentario de la demostración anterior:
· "(simp add: inversaAcAux_es_inversa inversaAc_def)" es el método de
demostración por simplificación usando como regla de simplificación
las propiedades inversaAcAux_es_inversa e inversaAc_def. ›

section ‹Demostración por inducción para funciones de orden superior ›

text ‹ ---------------------------------------------------------------
Ejemplo 22. 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 ‹---------------------------------------------------------------
Ejemplo 23. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3::nat,2,5] = [6,4,10]
map ((*) 2) [3::nat,2,5] = [6,4,10]
map ((+) 2) [3::nat,2,5] = [5,4,7]
------------------------------------------------------------------ ›

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]"
value "map ((*) 2) [3::nat,2,5] = [6,4,10]"
value "map ((+) 2) [3::nat,2,5] = [5,4,7]"

text ‹---------------------------------------------------------------
Ejemplo 24. (p. 45) Demostrar que
sum (map ((*) 2) xs) = 2 * (sum xs)
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
apply (induct xs)
(* 1. sum (map (( * ) 2) []) = 2 * sum []
2. ⋀a xs. sum (map (( * ) 2) xs) = 2 * sum xs ⟹
sum (map (( * ) 2) (a # xs)) = 2 * sum (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map ((*) 2) []) = 2 * (sum [])" by simp
next
fix a xs
assume HI: "sum (map ((*) 2) xs) = 2 * (sum xs)"
have "sum (map ((*) 2) (a#xs)) = sum ((2*a)#(map ((*) 2) xs))"
by simp
also have "… = 2*a + sum (map ((*) 2) xs)"
by simp
also have "… = 2*a + 2*(sum xs)"
using HI by simp
also have "… = 2*(a + sum xs)"
by simp
also have "… = 2*(sum (a#xs))"
by simp
finally show "sum (map ((*) 2) (a#xs)) = 2*(sum (a#xs))"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "sum (map ((*) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map ((*) 2) []) = 2 * (sum [])"
by (simp only: map.simps(1)
sum.simps(1))
next
fix a xs
assume HI: "sum (map ((*) 2) xs) = 2 * (sum xs)"
have "sum (map ((*) 2) (a#xs)) = sum ((2*a)#(map ((*) 2) xs))"
by (simp only: map.simps(2))
also have "… = 2*a + sum (map ((*) 2) xs)"
by (simp only: sum.simps(2))
also have "… = 2*a + 2*(sum xs)"
using HI by (simp only:)
also have "… = 2*(a + sum xs)"
find_theorems "_ * (_ + _)"
by (simp only: add_mult_distrib2)
also have "… = 2*(sum (a#xs))"
by (simp only: sum.simps(2))
finally show "sum (map ((*) 2) (a#xs)) = 2*(sum (a#xs))"
by this
qed

text ‹ ---------------------------------------------------------------
Ejemplo 25. (p. 48) Demostrar que
longitud (map f xs) = longitud xs
------------------------------------------------------------------- ›

(* La demostración aplicativa es *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
(* 1. longitud (map f []) = longitud []
2. ⋀a xs. longitud (map f xs) = longitud xs ⟹
longitud (map f (a # xs)) = longitud (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []"
by simp
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))"
by simp
also have "… = 1 + longitud (map f xs)"
by simp
also have "… = 1 + longitud xs"
using HI by simp
also have "… = longitud (a#xs)"
by simp
finally show "longitud (map f (a#xs)) = longitud (a#xs)"
by simp
qed

(* La demostración declarativa detallada es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []"
by (simp only: map.simps(1)
longitud.simps(1))
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))"
by (simp only: map.simps(2))
also have "… = 1 + longitud (map f xs)"
by (simp only: longitud.simps(2))
also have "… = 1 + longitud xs"
using HI by (simp only:)
also have "… = longitud (a#xs)"
by (simp only: longitud.simps(2))
finally show "longitud (map f (a#xs)) = longitud (a#xs)"
by this
qed

section ‹Referencias›

text ‹
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms".
· S. Thompson. "Haskell: the Craft of Functional Programming, 3rd
Edition. Cap. 8 "Reasoning about programms".
· L. Paulson. "ML for the Working Programmer, 2nd Edition". Cap. 6.
"Reasoning about functional programs".
›

end
</source>

Programación funcional en Isabelle/HOL

2020-04-01T19:03:10Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 5 Programación funcional en Isabelle›

theory T5_Programacion_funcional_en_Isabelle
imports Main
begin

section ‹Introducción›

text ‹En este tema se presenta el lenguaje funcional que está
incluido en Isabelle. El lenguaje funcional es muy parecido a
Haskell.›

section ‹Números naturales, enteros y booleanos›

text ‹En Isabelle están definidos los número naturales con la sintaxis
de Peano usando dos constructores: 0 (cero) y Suc (el sucesor).

Los números como el 1 son abreviaturas de los correspondientes en la
notación de Peano, en este caso "Suc 0".

El tipo de los números naturales es nat.

Por ejemplo, el siguiente del 0 es el 1.›

value "Suc 0"
(* ↝ "1" :: "nat"*)

text ‹En Isabelle está definida la suma de los números naturales:
(x + y) es la suma de x e y.

Por ejemplo, la suma de los números naturales 1 y 2 es el número
natural 3.›

value "(1::nat) + 2"
(* ↝ "3" :: "nat" *)

value "(1::nat) + 2 = 3"
(* ↝ "True" :: "bool" *)

text ‹La notación del par de dos puntos se usa para asignar un tipo a
un término (por ejemplo, (1::nat) significa que se considera que 1 es
un número natural).

En Isabelle está definida el producto de los números naturales:
(x * y) es el producto de x e y.

Por ejemplo, el producto de los números naturales 2 y 3 es el número
natural 6.›

value "(2::nat) * 3"
(* ↝ "6" :: "nat"*)

value "(2::nat) * 3 = 6"
(* ↝ "True" :: "bool" *)

text ‹En Isabelle está definida la división de números naturales:
(n div m) es el cociente entero de x entre y.

Por ejemplo, la división natural de 7 entre 3 es 2.›

value "(7::nat) div 3"
(* ↝ "2" :: "nat" *)

value "(7::nat) div 3 = 2"
(* ↝ "True" :: "bool" *)

text ‹En Isabelle está definida el resto de división de números
naturales: (n mod m) es el resto de dividir n entre m.

Por ejemplo, el resto de dividir 7 entre 3 es 1.›

value "(7::nat) mod 3"
(* ↝ "1" :: "nat" *)

text ‹En Isabelle también están definidos los números enteros. El tipo
de los enteros se representa por int.

Por ejemplo, la suma de 1 y -2 es el número entero -1.›

value "(1::int) + -2"
(* ↝ "- 1" :: "int"*)

text ‹Los numerales están sobrecargados. Por ejemplo, el 1 puede ser
un natural o un entero, dependiendo del contexto.

Isabelle resuelve ambigüedades mediante inferencia de tipos.

A veces, es necesario usar declaraciones de tipo para resolver la
ambigüedad.

En Isabelle están definidos los valores booleanos (True y False), las
conectivas (¬, ∧, ∨, ⟶ y ↔) y los cuantificadores (∀ y ∃).

El tipo de los booleanos es bool.›

text ‹La conjunción de dos fórmulas verdaderas es verdadera.›
value "True ∧ True"
(* ↝ "True" :: "bool" *)

text ‹La conjunción de un fórmula verdadera y una falsa es falsa.›
value "True ∧ False"
(* ↝ "False" :: "bool" *)

text ‹La disyunción de una fórmula verdadera y una falsa es
verdadera.›
value "True ∨ False"
(* ↝ "True" :: "bool" *)

text ‹La disyunción de dos fórmulas falsas es falsa.›
value "False ∨ False"
(* ↝ "False" :: "bool"*)

text ‹La negación de una fórmula verdadera es falsa.›
value "¬True"
(* ↝ "False" :: "bool"*)

text ‹Una fórmula falsa implica una fórmula verdadera.›
value "False ⟶ True"
(* ↝ "True" :: "bool"*)

text ‹Un lema introduce una proposición seguida de una demostración.

Isabelle dispone de varios procedimientos automáticos para generar
demostraciones, uno de los cuales es el de simplificación (llamado
simp).

El procedimiento simp aplica un conjunto de reglas de reescritura, que
inicialmente contiene un gran número de reglas relativas a los objetos
definidos.›

text ‹Ej. de simp: Todo elemento es igual a sí mismo.›

lemma "∀x. x = x"
by simp

text ‹Ej. de simp: Existe un elemento igual a 1.›

lemma "∃x. x = 1"
by simp

section ‹Definiciones no recursivas›

text ‹La disyunción exclusiva de A y B se verifica si una es verdadera
y la otra no lo es.›

definition xor :: "bool ⇒ bool ⇒ bool" where
"xor A B ≡ (A ∧ ¬B) ∨ (¬A ∧ B)"

text ‹Prop.: La disyunción exclusiva de dos fórmulas verdaderas es
falsa.

Dem.: Por simplificación, usando la definición de la disyunción
exclusiva.›

lemma "xor True True = False"
by (simp add: xor_def)

text ‹Se añade la definición de la disyunción exclusiva al conjunto de
reglas de simplificación automáticas.›

declare xor_def [simp]

lemma "xor True False = True"
by simp

section ‹Definiciones locales›

text ‹Se puede asignar valores a variables locales mediante 'let' y
usarlo en las expresiones dentro de 'in'.

Por ejemplo, si x es el número natural 3, entonces "x*x = 9".›

value "let x = 3::nat in x * x"
(* ↝ "9" :: "nat" *)

section ‹Pares›

text ‹Un par se representa escribiendo los elementos entre paréntesis
y separados por coma.

El tipo de los pares es el producto de los tipos.

La función fst devuelve el primer elemento de un par y la snd el
segundo.

Por ejemplo, si p es el par de números naturales (2,3), entonces la
suma del primer elemento de p y 1 es igual al segundo elemento de
p.›

value "let p = (2,3)::nat × nat in fst p + 1 = snd p"
(* ↝ "True" :: "bool" *)

section ‹Listas›

text ‹Una lista se representa escribiendo los elementos entre
corchetes y separados por comas.

La lista vacía se representa por [].

Todos los elementos de una lista tienen que ser del mismo tipo.

El tipo de las listas de elementos del tipo a es (a list).

El término (x#xs) representa la lista obtenida añadiendo el elemento x
al principio de la lista xs.

Por ejemplo, la lista obtenida añadiendo sucesivamente a la lista
vacía los elementos z, y y x a es [x,y,z].›

value "x#(y#(z#[]))"
(* ↝ "[x, y, z]" :: "'a list" *)

value "(1::int)#(2#(3#[]))"
(* ↝ "[1, 2, 3]" :: "int list" *)

text ‹Funciones de descomposición de listas:
· (hd xs) es el primer elemento de la lista xs.
· (tl xs) es el resto de la lista xs.

Por ejemplo, si xs es la lista [a,b,c], entonces el primero de xs es a
y el resto de xs es [b,c].›

value "let xs = [a,b,c] in hd xs = a ∧ tl xs = [b,c]"
(* ↝ "True" :: "bool" *)

text ‹(length xs) es la longitud de la lista xs. Por ejemplo, la
longitud de la lista [1,2,5] es 3.›

value "length [1::nat,2,5]"
(* ↝ "3" :: "nat" *)

text ‹En la página 10 de "What's in Main"
https://isabelle.in.tum.de/dist/Isabelle2018/doc/main.pdf
y en la sesión 66 de "Isabelle/HOL — Higher-Order Logic"
https://isabelle.in.tum.de/dist/library/HOL/HOL/document.pdf
se encuentran más definiciones y propiedades de las listas.›

section ‹Funciones anónimas›

text ‹En Isabelle pueden definirse funciones anónimas.

Por ejemplo, el valor de la función que a un número le asigna su doble
aplicada a 1 es 2.›

value "(λx. x + x) 1::nat"
(* ↝ "2" :: "nat" *)

section ‹Condicionales›

text ‹El valor absoluto del entero x es x, si "x ≥ 0" y es -x en caso
contrario.›

definition absoluto :: "int ⇒ int" where
"absoluto x ≡ (if x ≥ 0 then x else -x)"

text ‹Ejemplo, el valor absoluto de -3 es 3.›

value "absoluto(-3)"
(* ↝ "3" :: "int" *)

text ‹Def.: Un número natural n es un sucesor si es de la forma
(Suc m).›

definition es_sucesor :: "nat ⇒ bool" where
"es_sucesor n ≡ (case n of
0 ⇒ False
| Suc m ⇒ True)"

text ‹Ejemplo, el número 3 es sucesor.›

value "es_sucesor 3"
(* ↝ "True" :: "bool" *)

section ‹Tipos de datos y definiciones recursivas›

text ‹Una lista de elementos de tipo a es la lista Vacia o se obtiene
añadiendo, con Cons, un elemento de tipo a a una lista de elementos de
tipo a.›

datatype 'a Lista = Vacia | Cons 'a "'a Lista"

text ‹(conc xs ys) es la concatenación de las lista xs e ys. Por
ejemplo,
conc (Cons a (Cons b Vacia)) (Cons c Vacia)
= Cons a (Cons b (Cons c Vacia))
›

fun conc :: "'a Lista ⇒ 'a Lista ⇒ 'a Lista" where
"conc Vacia ys = ys"
| "conc (Cons x xs) ys = Cons x (conc xs ys)"

value "conc (Cons a (Cons b Vacia)) (Cons c Vacia)"
(* ↝ Lista.Cons a (Lista.Cons b (Lista.Cons c Vacia)) *)

text ‹Se puede declarar que acorte los nombres.›

declare [[names_short]]

value "conc (Cons a (Cons b Vacia)) (Cons c Vacia)"
(* ↝ Cons a (Cons b (Cons c Vacia) *)

text ‹(suma n) es la suma de los primeros n números naturales. Por
ejemplo,
suma 3 = 6
›

fun suma :: "nat ⇒ nat" where
"suma 0 = 0"
| "suma (Suc m) = (Suc m) + suma m"

value "suma 3"
(* ↝ "6" :: nat *)

text ‹(sumaImpares n) es la suma de los n primeros números impares.
Por ejemplo,
sumaImpares 3 = 9
›

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

value "sumaImpares 3"
(* ↝ "9" :: nat *)

end
</source>

Ejercicios

2020-02-20T16:07:55Z

Jalonso:

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]])
* '''Relación 2''': Deducción natural en lógica proposicional. ([[R2 |Enunciado]]).
* '''Relación 3''': Deducción natural en lógica proposicional (II). ([[R3 |Enunciado]]).
* '''Relación 4''': Deducción natural en lógica proposicional con Isabelle ([[R4 |Enunciado]]).
* '''Relación 5''': Sintaxis y semántica de la lógica de primer orden. ([[R5 |Enunciado]]).
* '''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 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 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 9''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R9.thy Programación funcional en Isabelle] ([[R9 |Enunciado]]).
* '''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 11''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R11.thy Razonamiento sobre programas en Isabelle/HOL] ([[R11 |Enunciado]]).
* '''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 13''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R13.thy Definiciones inductivas: clausuras] ([[R13 |Enunciado]]).
* '''Relación 14''': [https://www.cs.us.es/~mjoseh/cursos/lmf-18/relaciones_ejercicios/R14.thy Desarrollo de teorías axiomáticas] ([[R14 |Enunciado]]).

Deducción natural proposicional con Isabelle/HOL

2020-02-19T19:39:55Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 2a: Deducción natural proposicional con Isabelle/HOL›

theory T2a_Deduccion_natural_en_logica_proposicional_con_Isabelle
imports Main
begin

text ‹En este tema se presentan los ejemplos del tema de deducción
natural proposicional siguiendo la presentación de Huth y Ryan en su
libro "Logic in Computer Science" http://goo.gl/qsVpY y, más
concretamente, a la forma como se explica en la asignatura de
"Lógica informática" (LI) http://goo.gl/AwDiv

La página al lado de cada ejemplo indica la página de las
transparencias de LI donde se encuentra la demostración.›

section ‹Reglas de la conjunción›

text ‹ Notas sobre la lógica: Las reglas de la conjunción son
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q ›

thm conjI
thm conjunct1
thm conjunct2

subsection ‹Ejemplo 1›

text ‹Ejemplo 1 (p. 4). Demostrar que
p ∧ q, r ⊢ q ∧ r. ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_1:
"⟦p ∧ q; r⟧ ⟹ q ∧ r"
apply (rule conjI)
apply (erule conjunct2)
apply assumption
done

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "⟦ ... ⟧" para representar las hipótesis,
· ";" para separar las hipótesis y
· "⟹" para separar las hipótesis de la conclusión.›

subsubsection ‹Demostración detallada›

lemma ejemplo_1_1:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 by (rule conjunct2)
show 4: "q ∧ r" using 3 2 by (rule conjI)
qed

text ‹Notas sobre el lenguaje: En la demostración anterior se ha usado
· "assumes" para indicar las hipótesis,
· "and" para separar las hipótesis,
· "shows" para indicar la conclusión,
· "proof" para iniciar la prueba,
· "qed" para terminar la pruebas,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "using" para usar hechos en un paso,
· "by (rule ..)" para indicar la regla con la que se peueba un hecho,
· "show" para establecer la conclusión.›

subsubsection ‹Demostración estructurada›

text ‹Se pueden dejar implícitas las reglas como sigue›

lemma ejemplo_1_2:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 ..
show 4: "q ∧ r" using 3 2 ..
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· ".." para indicar que se prueba por la regla correspondiente.›

text ‹Se pueden eliminar las etiquetas como sigue›

lemma ejemplo_1_3:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof -
have "q" using assms(1) ..
then show "q ∧ r" using assms(2) ..
qed

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms(n)" para indicar la hipótesis n y
· "then show" para demostrar la conclusión usando el hecho anterior.
Además, no es necesario usar and entre las hipótesis.›

subsubsection ‹Demostración automática›

lemma ejemplo_1_4:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms
by auto

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms" para indicar las hipótesis y
· "by auto" para demostrar la conclusión automáticamente.›

subsubsection ‹Demostración detallada hacia atrás›

text ‹Se puede hacer la demostración por razonamiento hacia atrás,
como sigue›

lemma ejemplo_1_5:
assumes "p ∧ q"
and "r"
shows "q ∧ r"
proof (rule conjI)
show "q" using assms(1) by (rule conjunct2)
next
show "r" using assms(2) by this
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "proof (rule r)" para indicar que se hará la demostración con la
regla r,
· "next" para indicar el comienzo de la prueba del siguiente
subobjetivo,
· "this" para indicar el hecho actual.›

subsubsection ‹Demostración estructurada hacia atrás›

text ‹Se pueden dejar implícitas las reglas como sigue›

lemma ejemplo_1_6:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof
show "q" using assms(1) ..
next
show "r" using assms(2) .
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "." para indicar por el hecho actual.›

subsubsection ‹Demostraciones automáticas›

lemma ejemplo_1_7:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms by simp

― ‹Se puede acortar como sigue›
lemma ejemplo_1_8_:
"⟦p ∧ q; r⟧ ⟹ q ∧ r"
by simp

section ‹Reglas de la doble negación›

subsection ‹Reglas de la doble negación›

text ‹La regla de eliminación de la doble negación es
· notnotD: ¬¬ P ⟹ P

Para ajustarnos al tema de LI vamos a introducir la siguiente regla de
introducción de la doble negación
· notnotI: P ⟹ ¬¬ P
aunque, de momento, no detallamos su demostración.›

lemma notnotI [intro!]: "P ⟹ ¬¬ P"
by auto

subsection ‹Ejemplo 2›

text ‹Ejemplo 2. (p. 5)
p, ¬¬(q ∧ r) ⊢ ¬¬p ∧ r ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_2:
"⟦p; ¬¬(q ∧ r)⟧ ⟹ ¬¬p ∧ r"
apply (rule conjI)
apply (rule notnotI)
apply assumption
apply (drule notnotD)
apply (erule conjunct2)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_2_1:
assumes 1: "p" and
2: "¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have 3: "¬¬p" using 1 by (rule notnotI)
have 4: "q ∧ r" using 2 by (rule notnotD)
have 5: "r" using 4 by (rule conjunct2)
show 6: "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

subsubsection ‹Demostración estructurada›

― ‹Se puede eliminar etiquetas y reglas›
lemma ejemplo_2_2:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have "¬¬p" using assms(1) ..
have "q ∧ r" using assms(2) by (rule notnotD)
then have "r" ..
with ‹¬¬p› show "¬¬p ∧ r" ..
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· ‹...› para referenciar un hecho y
· "with P show Q" para indicar que con el hecho anterior junto con el
hecho P se demuestra Q.›

subsubsection ‹Demostración detallada hacia atrás›

lemma ejemplo_2_3:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof (rule conjI)
show "¬¬p" using assms(1) by (rule notnotI)
next
have "q ∧ r" using assms(2) by (rule notnotD)
then show "r" by (rule conjunct2)
qed

subsubsection ‹Demostración estructurada hacia atrás›

text ‹Se puede eliminar las reglas en la demostración anterior, como
sigue:›

lemma ejemplo_2_4:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof
show "¬¬p" using assms(1) ..
next
have "q ∧ r" using assms(2) by (rule notnotD)
then show "r" ..
qed

subsubsection ‹Demostraciones automáticas›

lemma ejemplo_2_5:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
using assms
by simp

― ‹Se puede simplificar›
lemma ejemplo_2_6:
"⟦p; ¬¬(q ∧ r)⟧ ⟹ ¬¬p ∧ r"
by simp

section ‹Regla de eliminación del condicional›

text ‹La regla de eliminación del condicional es la regla del modus
ponens
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q ›

subsection ‹Ejemplo 3›

text ‹Ejemplo 3. (p. 6) Demostrar que
¬p ∧ q, ¬p ∧ q ⟶ r ∨ ¬p ⊢ r ∨ ¬p ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_3:
"⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p"
apply (erule mp)
apply assumption
done

subsubsection ‹Demostración detallada›

lemma ejemplo_3_1:
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_3_2:
assumes "¬p ∧ q"
"¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using assms(2,1) ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_3_3:
"⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p"
by simp

subsection ‹Ejemplo 4›

text ‹Ejemplo 4 (p. 6) Demostrar que
p, p ⟶ q, p ⟶ (q ⟶ r) ⊢ r ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_4_1:
assumes 1: "p" and
2: "p ⟶ q" and
3: "p ⟶ (q ⟶ r)"
shows "r"
proof -
have 4: "q" using 2 1 by (rule mp)
have 5: "q ⟶ r" using 3 1 by (rule mp)
show 6: "r" using 5 4 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_4_2:
assumes "p"
"p ⟶ q"
"p ⟶ (q ⟶ r)"
shows "r"
proof -
have "q" using assms(2,1) ..
have "q ⟶ r" using assms(3,1) ..
then show "r" using ‹q› ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_4_3:
"⟦p; p ⟶ q; p ⟶ (q ⟶ r)⟧ ⟹ r"
by simp

section ‹Regla derivada del modus tollens›

text ‹Para ajustarnos al tema de LI vamos a introducir la regla del
modus tollens
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
aunque, de momento, sin detallar su demostración.›

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

subsection ‹Ejemplo 5›

text ‹Ejemplo 5 (p. 7). Demostrar
p ⟶ (q ⟶ r), p, ¬r ⊢ ¬q ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_5:
"⟦p ⟶ (q ⟶ r); p; ¬r ⟧ ⟹ ¬q"
apply (drule mp)
apply assumption
apply (erule mt)
apply assumption
done

subsubsection ‹Demostración detallada›

lemma ejemplo_5_1:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof -
have 4: "q ⟶ r" using 1 2 by (rule mp)
show "¬q" using 4 3 by (rule mt)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_5_2:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
proof -
have "q ⟶ r" using assms(1,2) ..
then show "¬q" using assms(3) by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_5_3:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
using assms
by simp

lemma ejemplo_5_4:
"⟦p ⟶ (q ⟶ r); p; ¬r ⟧ ⟹ ¬q"
by simp

subsection ‹Ejemplo 6›

text ‹Ejemplo 6. (p. 7) Demostrar
¬p ⟶ q, ¬q ⊢ p ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_6:
"⟦¬p ⟶ q; ¬q⟧ ⟹ p"
apply (drule mt)
apply assumption
apply (erule notnotD)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_6_1:
assumes 1: "¬p ⟶ q" and
2: "¬q"
shows "p"
proof -
have 3: "¬¬p" using 1 2 by (rule mt)
show "p" using 3 by (rule notnotD)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_6_2:
assumes "¬p ⟶ q"
"¬q"
shows "p"
proof -
have "¬¬p" using assms(1,2) by (rule mt)
then show "p" by (rule notnotD)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_6_3:
"⟦¬p ⟶ q; ¬q⟧ ⟹ p"
by simp

subsection ‹Ejemplo 7›

text ‹Ejemplo 7. (p. 7) Demostrar
p ⟶ ¬q, q ⊢ ¬p ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_7:
"⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
apply (erule mt)
apply (erule notnotI)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_7_1:
assumes 1: "p ⟶ ¬q" and
2: "q"
shows "¬p"
proof -
have 3: "¬¬q" using 2 by (rule notnotI)
show "¬p" using 1 3 by (rule mt)
qed

lemma ejemplo_7_2:
assumes "p ⟶ ¬q"
"q"
shows "¬p"
proof -
have "¬¬q" using assms(2) by (rule notnotI)
with assms(1) show "¬p" by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_7_3:
"⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
by simp

section ‹Regla de introducción del condicional›

text ‹La regla de introducción del condicional es
· impI: (P ⟹ Q) ⟹ P ⟶ Q ›

subsection ‹Ejemplo 8›

text ‹Ejemplo 8. (p. 8) Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_8_1:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 2: "¬q"
have "¬p" using 1 2 by (rule mt) }
then show "¬q ⟶ ¬p" by (rule impI)
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "{ ... }" para representar una caja.›

subsubsection ‹Demostración estructurada›

lemma ejemplo_8_2:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with assms show "¬p" by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_8_3:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
using assms
by auto

subsection ‹Ejemplo 9›

text ‹Ejemplo 9. (p. 9) Demostrar
¬q ⟶ ¬p ⊢ p ⟶ ¬¬q ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_9:
"¬q ⟶ ¬p ⟹ p ⟶ ¬¬q"
apply (rule impI)
apply (erule mt)
apply (erule notnotI)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_9_1:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof -
{ assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt) }
then show "p ⟶ ¬¬q" by (rule impI)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_9_2:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof
assume "p"
then have "¬¬p" by (rule notnotI)
with assms show "¬¬q" by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_9_3:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
using assms
by auto

subsection ‹Ejemplo 10›

text ‹Ejemplo 10 (p. 9). Demostrar
⊢ p ⟶ p ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_10_1:
"p ⟶ p"
proof -
{ assume 1: "p"
have "p" using 1 by this }
then show "p ⟶ p" by (rule impI)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_10_2:
"p ⟶ p"
proof (rule impI)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_10_3:
"p ⟶ p"
by simp

subsection ‹Ejemplo 11›

text ‹Ejemplo 11 (p. 10) Demostrar
⊢ (q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_11:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
apply (rule impI)+
apply (erule mp)
apply (drule mt)
apply (erule notnotI)
apply (erule notnotD)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_11_1:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof -
{ assume 1: "q ⟶ r"
{ assume 2: "¬q ⟶ ¬p"
{ assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
have "r" using 1 6 by (rule mp) }
then have "p ⟶ r" by (rule impI) }
then have "(¬q ⟶ ¬p) ⟶ p ⟶ r" by (rule impI) }
then show "(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ p ⟶ r)" by (rule impI)
qed

― ‹La demostración hacia atrás es›
lemma ejemplo_11_2:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 by (rule mp)
qed
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_11_3:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume 3: "p"
have 4: "¬¬p" using 3 ..
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 ..
qed
qed
qed

― ‹La demostración sin etiquetas es›
lemma ejemplo_11_4:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume "p"
then have "¬¬p" ..
with ‹¬q ⟶ ¬p› have "¬¬q" by (rule mt)
then have "q" by (rule notnotD)
with ‹q ⟶ r› show "r" ..
qed
qed
qed

subsubsection ‹Demostración automática›

lemma ejemplo_11_5:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
by auto

section ‹Reglas de la disyunción›

text ‹Las reglas de la introducción de la disyunción son
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
La regla de elimación de la disyunción es
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R ›

subsection ‹Ejemplo 12›

text ‹Ejemplo 12 (p. 11). Demostrar
p ∨ q ⊢ q ∨ p ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_12_1:
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

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "moreover" para separar los bloques y
· "ultimately" para unir los resultados de los bloques.›

subsubsection ‹Demostración estructurada›

― ‹La demostración detallada con reglas implícitas es›
lemma ejemplo_12_2:
assumes "p ∨ q"
shows "q ∨ p"
proof -
note ‹p ∨ q›
moreover
{ assume "p"
then have "q ∨ p" .. }
moreover
{ assume "q"
then have "q ∨ p" .. }
ultimately show "q ∨ p" ..
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "note" para copiar un hecho.›

subsubsection ‹Demostración detallada hacia atrás›

lemma ejemplo_12_3:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1
proof (rule disjE)
{ assume 2: "p"
show "q ∨ p" using 2 by (rule disjI2) }
next
{ assume 3: "q"
show "q ∨ p" using 3 by (rule disjI1) }
qed

subsubsection ‹Demostración estructurada hacia atrás›

lemma ejemplo_12_4:
assumes "p ∨ q"
shows "q ∨ p"
using assms
proof
{ assume "p"
then show "q ∨ p" .. }
next
{ assume "q"
then show "q ∨ p" .. }
qed

subsubsection ‹Demostración automática›

lemma ejemplo_12_5:
assumes "p ∨ q"
shows "q ∨ p"
using assms
by auto

subsection ‹Ejemplo 13›

text ‹Ejemplo 13. (p. 12) Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_13_1:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q"
then show "p ∨ r"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ r" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "r" using 1 4 by (rule mp)
show "p ∨ r" using 5 by (rule disjI2) }
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_13_2:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
then show "p ∨ r"
proof
{ assume "p"
then show "p ∨ r" .. }
next
{ assume "q"
have "r" using assms ‹q› ..
then show "p ∨ r" .. }
qed
qed

subsubsection ‹Demostración automática›

lemma ejemplo_13_3:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
using assms
by auto

section ‹Regla de copia›

subsection ‹Ejemplo 14›

text ‹Ejemplo 14 (p. 13). Demostrar
⊢ p ⟶ (q ⟶ p) ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_14_1:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using 1 by this
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_14_2:
"p ⟶ (q ⟶ p)"
proof
assume "p"
then show "q ⟶ p" ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_14_3:
"p ⟶ (q ⟶ p)"
by simp

section ‹Reglas de la negación›

text ‹La regla de eliminación de lo falso es
· FalseE: False ⟹ P
La regla de eliminación de la negación es
· notE: ⟦¬P; P⟧ ⟹ R
La regla de introducción de la negación es
· notI: (P ⟹ False) ⟹ ¬P ›

subsection ‹Ejemplo 15›

text ‹Ejemplo 15 (p. 15). Demostrar
¬p ∨ q ⊢ p ⟶ q ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_15:
"¬p ∨ q ⟹ p ⟶ q"
apply (rule impI)
apply (erule disjE)
apply (erule notE)
apply assumption+
done

subsubsection ‹Demostración detallada›

lemma ejemplo_15_1:
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p"
note 1
then show "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume 4: "q"
show "q" using 4 by this}
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_15_2:
assumes "¬p ∨ q"
shows "p ⟶ q"
proof
assume "p"
note ‹¬p ∨ q›
then show "q"
proof
assume "¬p"
then show "q" using ‹p› ..
next
assume "q"
then show "q" .
qed
qed

subsubsection ‹Demostración automática›

lemma ejemplo_15_3:
assumes "¬p ∨ q"
shows "p ⟶ q"
using assms
by auto

subsection ‹Ejemplo 16›

text ‹Ejemplo 16 (p. 16). Demostrar
p ⟶ q, p ⟶ ¬q ⊢ ¬p ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_16:
"⟦p ⟶ q; p ⟶ ¬q⟧ ⟹ ¬p"
apply (rule notI)
apply (drule mp)+
apply assumption+
apply (drule mp)
apply assumption
apply (erule notE)
apply assumption
done

subsubsection ‹Demostración detallada›

lemma ejemplo_16_1:
assumes 1: "p ⟶ q" and
2: "p ⟶ ¬q"
shows "¬p"
proof (rule notI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "¬q" using 2 3 by (rule mp)
show False using 5 4 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_16_2:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
proof
assume "p"
have "q" using assms(1) ‹p› ..
have "¬q" using assms(2) ‹p› ..
then show False using ‹q› ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_16_3:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
using assms
by simp

section ‹Reglas del bicondicional›

text ‹La regla de introducción del bicondicional es
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P ⟷ Q
Las reglas de eliminación del bicondicional son
· iffD1: ⟦Q ⟷ P; Q⟧ ⟹ P
· iffD2: ⟦P ⟷ Q; Q⟧ ⟹ P ›

subsection ‹Ejemplo 17›

text ‹Ejemplo 17 (p. 17) Demostrar
(p ∧ q) ⟷ (q ∧ p) ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_17_4:
"(p ∧ q) ⟷ (q ∧ p)"
apply (rule iffI)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_17_1:
"(p ∧ q) ⟷ (q ∧ p)"
proof (rule iffI)
{ assume 1: "p ∧ q"
have 2: "p" using 1 by (rule conjunct1)
have 3: "q" using 1 by (rule conjunct2)
show "q ∧ p" using 3 2 by (rule conjI) }
next
{ assume 4: "q ∧ p"
have 5: "q" using 4 by (rule conjunct1)
have 6: "p" using 4 by (rule conjunct2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_17_2:
"(p ∧ q) ⟷ (q ∧ p)"
proof
{ assume 1: "p ∧ q"
have "p" using 1 ..
have "q" using 1 ..
show "q ∧ p" using ‹q› ‹p› .. }
next
{ assume 2: "q ∧ p"
have "q" using 2 ..
have "p" using 2 ..
show "p ∧ q" using ‹p› ‹q› .. }
qed

subsubsection ‹Demostración automática›

lemma ejemplo_17_3:
"(p ∧ q) ⟷ (q ∧ p)"
by auto

subsection ‹Ejemplo 18›

text ‹Ejemplo 18 (p. 18). Demostrar
p ⟷ q, p ∨ q ⊢ p ∧ q ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_18_4:
"⟦p ⟷ q; p ∨ q⟧ ⟹ p ∧ q"
apply (erule disjE)
apply (rule conjI)
apply assumption
apply (erule iffD1)
apply assumption
apply (rule conjI)
apply (erule iffD2)
apply assumption+
done

subsubsection ‹Demostración detallada›

lemma ejemplo_18_1:
assumes 1: "p ⟷ q" and
2: "p ∨ q"
shows "p ∧ q"
using 2
proof (rule disjE)
{ assume 3: "p"
have 4: "q" using 1 3 by (rule iffD1)
show "p ∧ q" using 3 4 by (rule conjI) }
next
{ assume 5: "q"
have 6: "p" using 1 5 by (rule iffD2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_18_2:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms(2)
proof
{ assume "p"
with assms(1) have "q" ..
with ‹p› show "p ∧ q" .. }
next
{ assume "q"
with assms(1) have "p" ..
then show "p ∧ q" using ‹q› .. }
qed

subsubsection ‹Demostración automática›

lemma ejemplo_18_3:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms
by simp

section ‹Reglas derivadas›

subsection ‹Regla del modus tollens›

text ‹Ejemplo 19 (p. 20) Demostrar la regla del modus tollens a partir
de las reglas básicas.›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_20:
"⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
apply (rule notI)
apply (drule mp)
apply assumption
apply (erule notE)
apply assumption
done

subsubsection ‹Demostración detallada›

lemma ejemplo_20_1:
assumes 1: "F ⟶ G" and
2: "¬G"
shows "¬F"
proof (rule notI)
assume 3: "F"
have 4: "G" using 1 3 by (rule mp)
show False using 2 4 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_20_2:
assumes "F ⟶ G"
"¬G"
shows "¬F"
proof
assume "F"
with assms(1) have "G" ..
with assms(2) show False ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_20_3:
assumes "F ⟶ G"
"¬G"
shows "¬F"
using assms
by simp

subsection ‹Regla de la introducción de la doble negación›

text ‹Ejemplo 21 (p. 21) Demostrar la regla de introducción de la doble
negación a partir de las reglas básicas.›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_21:
"F ⟹ ¬¬F"
apply (rule notI)
apply (erule notE)
apply assumption
done

subsubsection ‹Demostración detallada›

lemma ejemplo_21_1:
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_21_2:
assumes "F"
shows "¬¬F"
proof
assume "¬F"
then show False using assms ..
qed

subsubsection ‹Demostración automática›

lemma ejemplo_21_3:
assumes "F"
shows "¬¬F"
using assms
by simp

subsection ‹Regla de reducción al absurdo›

text ‹La regla de reducción al absurdo en Isabelle se correponde con la
regla clásica de contradicción
· ccontr: (¬P ⟹ False) ⟹ P ›

subsection ‹Ley del tercio excluso›

text ‹La ley del tercio excluso es
· excluded_middle: ¬P ∨ P ›

text ‹Ejemplo 22 (p. 23). Demostrar la ley del tercio excluso a partir de
las reglas básicas.›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_22:
"F ∨ ¬F"
apply (rule ccontr)
apply (rule_tac P="F" in notE)
apply (rule notI)
apply (erule notE)
apply (erule disjI1)
apply (rule notnotD)
apply (rule notI)
apply (erule notE)
apply (erule disjI2)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_22_1:
"F ∨ ¬F"
proof (rule ccontr)
assume 1: "¬(F ∨ ¬F)"
then show False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume 2: "F"
then have 3: "F ∨ ¬F" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
qed
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_22_2:
"F ∨ ¬F"
proof (rule ccontr)
assume "¬(F ∨ ¬F)"
then show False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume "F"
then have "F ∨ ¬F" ..
with ‹¬(F ∨ ¬F)› show False ..
qed
qed
qed
qed

subsubsection ‹Demostración automática›

lemma ejemplo_22_3:
"F ∨ ¬F"
by simp

subsection ‹Ejemplo 23›

text ‹Ejemplo 23 (p. 24). Demostrar
p ⟶ q ⊢ ¬p ∨ q ›

subsubsection ‹Demostración aplicativa›

lemma ejemplo_23:
"p ⟶ q ⟹ ¬p ∨ q"
apply (cut_tac P="p" in excluded_middle)
apply (erule disjE)
apply (erule disjI1)
apply (drule mp)
apply assumption
apply (erule disjI2)
done

subsubsection ‹Demostración detallada›

lemma ejemplo_23_1:
assumes 1: "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
then show "¬p ∨ q"
proof (rule disjE)
{ assume "¬p"
then show "¬p ∨ q" by (rule disjI1) }
next
{ assume 2: "p"
have "q" using 1 2 by (rule mp)
then show "¬p ∨ q" by (rule disjI2) }
qed
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_23_2:
assumes "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" ..
then show "¬p ∨ q"
proof
{ assume "¬p"
then show "¬p ∨ q" .. }
next
{ assume "p"
with assms have "q" ..
then show "¬p ∨ q" .. }
qed
qed

subsubsection ‹Demostración automática›

lemma ejemplo_23_3:
assumes "p ⟶ q"
shows "¬p ∨ q"
using assms
by simp

section ‹Demostraciones por contradicción›

subsection ‹Ejemplo 24›

text ‹Ejemplo 24. Demostrar que
¬p, p ∨ q ⊢ q ›

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración detallada›

lemma ejemplo_24_1:
assumes "¬p"
"p ∨ q"
shows "q"
using ‹p ∨ q›
proof (rule disjE)
assume "p"
with assms(1) show "q" by contradiction
next
assume "q"
then show "q" by assumption
qed

subsubsection ‹Demostración estructurada›

lemma ejemplo_24_2:
assumes "¬p"
"p ∨ q"
shows "q"
using ‹p ∨ q›
proof
assume "p"
with assms(1) show "q" ..
next
assume "q"
then show "q" .
qed

subsubsection ‹Demostración automática›

lemma ejemplo_24_3:
assumes "¬p"
"p ∨ q"
shows "q"
using assms
by simp

end
</source>

Tema 4a

2020-02-07T20:03:45Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 4a: Deducción natural en lógica de primer orden›

theory T4a_Deduccion_natural_en_logica_de_primer_orden
imports Main
begin

text ‹El objetivo de este tema es presentar la deducción natural en
lógica de primer orden con Isabelle/HOL. La presentación se
basa en los ejemplos de tema 4 del curso LMF que se encuentra
en http://goo.gl/uJj8d (que a su vez se basa en el libro de
Huth y Ryan "Logic in Computer Science" http://goo.gl/qsVpY ).

La página al lado de cada ejemplo indica la página de las
transparencias de LMF donde se encuentra la demostración.›

section ‹Reglas del cuantificador universal›

text ‹Las reglas del cuantificador universal son
· allE: ⟦∀x. P x; P a ⟹ R⟧ ⟹ R
· allI: (⋀x. P x) ⟹ ∀x. P x
›

subsection ‹Ejemplo 1›

text ‹Ejemplo 1 (p. 10). Demostrar que
P(c), ∀x. (P(x) ⟶ ¬Q(x)) ⊢ ¬Q(c)
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_1a:
assumes 1: "P(c)" and
2: "∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
proof -
have 3: "P(c) ⟶ ¬Q(c)" using 2 by (rule allE)
show 4: "¬Q(c)" using 3 1 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_1b:
assumes "P(c)"
"∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
proof -
have "P(c) ⟶ ¬Q(c)" using assms(2) ..
then show "¬Q(c)" using assms(1) ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_1c:
assumes "P(c)"
"∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_1d:
"⟦P(c); ∀x. (P(x) ⟶ ¬Q(x))⟧ ⟹ ¬Q(c)"
apply (erule allE) (* da ⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c *)
apply (erule mp) (* da P c ⟹ P c *)
apply assumption (* da No subgoals! *)
done

text ‹Explicaciones
apply (erule allE)
+ Objetivo: "⟦P(c); ∀x. (P(x) ⟶ ¬Q(x))⟧ ⟹ ¬Q(c)"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("¬Q(c)", "∀x. (P(x) ⟶ ¬Q(x))") y
("?R", "∀x. ?P x")
es ?R / ¬Q(c)
?P x / P(x) ⟶ ¬Q(x)
+ Nuevo objetivo: "⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c"

apply (erule mp)
+ Objetivo: "⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c"
+ mp: "⟦?P ⟶ ?Q; ?P⟧ ⟹ ?Q"
+ Unificador de ("¬ Q c", "P ?x ⟶ ¬ Q ?x") y
("?Q", "?P ⟶ ?Q")
es ?Q / ¬ Q c
?P / P c
+ Nuevo objetivo: "P c ⟹ P c"
›

subsection ‹Ejemplo 2›

text ‹Ejemplo 2 (p. 11). Demostrar que
∀x. (P x ⟶ ¬(Q x)), ∀x. P x ⊢ ∀x. ¬(Q x)
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_2a:
assumes 1: "∀x. (P x ⟶ ¬(Q x))" and
2: "∀x. P x"
shows "∀x. ¬(Q x)"
proof -
{ fix a
have 3: "P a ⟶ ¬(Q a)" using 1 by (rule allE)
have 4: "P a" using 2 by (rule allE)
have 5: "¬(Q a)" using 3 4 by (rule mp) }
then show "∀x. ¬(Q x)" by (rule allI)
qed

― ‹La demostración detallada hacia atrás es›
lemma ejemplo_2b:
assumes 1: "∀x. (P x ⟶ ¬(Q x))" and
2: "∀x. P x"
shows "∀x. ¬(Q x)"
proof (rule allI)
fix a
have 3: "P a ⟶ ¬(Q a)" using 1 by (rule allE)
have 4: "P a" using 2 by (rule allE)
show 5: "¬(Q a)" using 3 4 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_2c:
assumes "∀x. (P x ⟶ ¬(Q x))"
"∀x. P x"
shows "∀x. ¬(Q x)"
proof
fix a
have "P a" using assms(2) ..
have "P a ⟶ ¬(Q a)" using assms(1) ..
then show "¬(Q a)" using ‹P a› ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_2d:
assumes "∀x. (P x ⟶ ¬(Q x))"
"∀x. P x"
shows "∀x. ¬(Q x)"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_2e:
"⟦∀x. (P x ⟶ ¬(Q x)); ∀y. P y⟧ ⟹ ∀z. ¬(Q z)"
apply (rule allI) (* da ⋀z. ⟦P (?x2 z) ⟶ ¬ Q (?x2 z);
P (?y4 z)⟧
⟹ ¬ Q z*)
apply (erule allE)+ (* da ⋀z. ⟦P (?x2 z) ⟶ ¬ Q (?x2 z);
P (?y4 z)⟧
⟹ ¬ Q z *)
apply (erule mp) (* da ⋀z. P (?y4 z) ⟹ P z *)
apply assumption (* da No subgoals! *)
done

section ‹Reglas del cuantificador existencial›

text ‹Las reglas del cuantificador existencial son
· exI: P a ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

En la regla exE la nueva variable se introduce mediante la declaración
"obtain ... where ... by (rule exE)"
›

subsection ‹Ejemplo 3›

text ‹Ejemplo 3 (p. 12). Demostrar que
∀x. P x ⊢ ∃x. P x
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_3a:
assumes "∀x. P x"
shows "∃x. P x"
proof -
fix a
have "P a" using assms by (rule allE)
then show "∃x. P x" by (rule exI)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_3b:
assumes "∀x. P x"
shows "∃x. P x"
proof -
fix a
have "P a" using assms ..
then show "∃x. P x" ..
qed

― ‹La demostración estructurada se puede simplificar›
lemma ejemplo_3c:
assumes "∀x. P x"
shows "∃x. P x"
proof (rule exI)
fix a
show "P a" using assms ..
qed

― ‹La demostración estructurada se puede simplificar aún más›
lemma ejemplo_3d:
assumes "∀x. P x"
shows "∃x. P x"
proof
fix a
show "P a" using assms ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_3e:
assumes "∀x. P x"
shows "∃x. P x"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_3f:
"∀x. P x ⟹ ∃y. P y"
apply (erule allE) (* da P ?x ⟹ ∃y. P y *)
apply (erule exI) (* da No subgoals! *)
done

subsection ‹Ejemplo 4›

text ‹Ejemplo 4 (p. 13). Demostrar
∀x. (P x ⟶ Q x), ∃x. P x ⊢ ∃x. Q x
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_4a:
assumes 1: "∀x. (P x ⟶ Q x)" and
2: "∃x. P x"
shows "∃x. Q x"
proof -
obtain a where 3: "P a" using 2 by (rule exE)
have 4: "P a ⟶ Q a" using 1 by (rule allE)
have 5: "Q a" using 4 3 by (rule mp)
then show 6: "∃x. Q x" by (rule exI)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_4b:
assumes "∀x. (P x ⟶ Q x)"
"∃x. P x"
shows "∃x. Q x"
proof -
obtain a where "P a" using assms(2) ..
have "P a ⟶ Q a" using assms(1) ..
then have "Q a" using ‹P a› ..
then show "∃x. Q x" ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_4c:
assumes "∀x. (P x ⟶ Q x)"
"∃x. P x"
shows "∃x. Q x"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_4f:
"⟦∀x. P x ⟶ Q x; ∃y. P y⟧ ⟹ ∃z. Q z"
apply (erule exE) (* da ⋀y. ⟦∀x. P x ⟶ Q x; P y⟧ ⟹ ∃z. Q z *)
apply (erule allE) (* da ⋀y. ⟦P y; P (?x2 y) ⟶ Q (?x2 y)⟧ ⟹ ∃z. Q z *)
apply (rule exI) (* da ⋀y. ⟦P y; P (?x2 y) ⟶ Q (?x2 y)⟧ ⟹ Q (?z4 y) *)
apply (erule mp) (* da ⋀y. P y ⟹ P (?x2 y) *)
apply assumption (* da No subgoals! *)
done

section ‹Demostración de equivalencias›

subsection ‹Ejemplo 5.1›

text ‹Ejemplo 5.1 (p. 15). Demostrar
¬∀x. P x ⊢ ∃x. ¬(P x)›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_5_1a:
assumes "¬(∀x. P(x))"
shows "∃x. ¬P(x)"
proof (rule ccontr)
assume "¬(∃x. ¬P(x))"
have "∀x. P(x)"
proof (rule allI)
fix a
show "P(a)"
proof (rule ccontr)
assume "¬P(a)"
then have "∃x. ¬P(x)" by (rule exI)
with ‹¬(∃x. ¬P(x))› show False by (rule notE)
qed
qed
with assms show False by (rule notE)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_5_1b:
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 (rule ccontr)
assume "¬P(a)"
then have "∃x. ¬P(x)" ..
with ‹¬(∃x. ¬P(x))› show False ..
qed
qed
with assms show False ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_5_1c:
assumes "¬(∀x. P(x))"
shows "∃x. ¬P(x)"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_5_1d: "¬(∀x. P x) ⟹ ∃y. ¬P y"
apply (rule ccontr) (* da ⟦¬ (∀x. P x); ∄y. ¬ P y⟧ ⟹ False *)
apply (erule notE) (* da ∄y. ¬ P y ⟹ ∀x. P x *)
apply (rule allI) (* da ⋀x. ∄y. ¬ P y ⟹ P x *)
apply (rule ccontr) (* da ⋀x. ⟦∄y. ¬ P y; ¬ P x⟧ ⟹ False *)
apply (erule notE) (* da ⋀x. ¬ P x ⟹ ∃y. ¬ P y *)
apply (erule exI) (* da No subgoals! *)
done

text ‹
Ejemplo 5.2 (p. 16). Demostrar
∃x. ¬(P x) ⊢ ¬∀x. P x›

― ‹La demostración detallada es›
lemma ejemplo_5_2a:
assumes "∃x. ¬P(x)"
shows "¬(∀x. P(x))"
proof (rule notI)
assume "∀x. P(x)"
obtain a where "¬P(a)" using assms by (rule exE)
have "P(a)" using ‹∀x. P(x)› by (rule allE)
with ‹¬P(a)› show False by (rule notE)
qed

― ‹La demostración estructurada es›
lemma ejemplo_5_2b:
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

― ‹La demostración automática es›
lemma ejemplo_5_2c:
assumes "∃x. ¬P(x)"
shows "¬(∀x. P(x))"
using assms
by auto

text ‹
Ejemplo 5.3 (p. 17). Demostrar
⊢ ¬∀x. P x ⟷ ∃x. ¬(P x)›

― ‹La demostración detallada es›
lemma ejemplo_5_3a:
"(¬(∀x. P(x))) ⟷ (∃x. ¬P(x))"
proof (rule iffI)
assume "¬(∀x. P(x))"
then show "∃x. ¬P(x)" by (rule ejemplo_5_1a)
next
assume "∃x. ¬P(x)"
then show "¬(∀x. P(x))" by (rule ejemplo_5_2a)
qed

― ‹La demostración automática es›
lemma ejemplo_5_3b:
"(¬(∀x. P(x))) ⟷ (∃x. ¬P(x))"
by auto

text ‹
Ejemplo 6.1 (p. 18). Demostrar
∀x. P(x) ∧ Q(x) ⊢ (∀x. P(x)) ∧ (∀x. Q(x))›

― ‹La demostración detallada es›
lemma ejemplo_6_1a:
assumes "∀x. P(x) ∧ Q(x)"
shows "(∀x. P(x)) ∧ (∀x. Q(x))"
proof (rule conjI)
show "∀x. P(x)"
proof (rule allI)
fix a
have "P(a) ∧ Q(a)" using assms by (rule allE)
then show "P(a)" by (rule conjunct1)
qed
next
show "∀x. Q(x)"
proof (rule allI)
fix a
have "P(a) ∧ Q(a)" using assms by (rule allE)
then show "Q(a)" by (rule conjunct2)
qed
qed

― ‹La demostración estructurada es›
lemma ejemplo_6_1b:
assumes "∀x. P(x) ∧ Q(x)"
shows "(∀x. P(x)) ∧ (∀x. Q(x))"
proof
show "∀x. P(x)"
proof
fix a
have "P(a) ∧ Q(a)" using assms ..
then show "P(a)" ..
qed
next
show "∀x. Q(x)"
proof
fix a
have "P(a) ∧ Q(a)" using assms ..
then show "Q(a)" ..
qed
qed

― ‹La demostración automática es›
lemma ejemplo_6_1c:
assumes "∀x. P(x) ∧ Q(x)"
shows "(∀x. P(x)) ∧ (∀x. Q(x))"
using assms
by auto

text ‹
Ejemplo 6.2 (p. 19). Demostrar
(∀x. P(x)) ∧ (∀x. Q(x)) ⊢ ∀x. P(x) ∧ Q(x)›

― ‹La demostración detallada es›
lemma ejemplo_6_2a:
assumes "(∀x. P(x)) ∧ (∀x. Q(x))"
shows "∀x. P(x) ∧ Q(x)"
proof (rule allI)
fix a
have "∀x. P(x)" using assms by (rule conjunct1)
then have "P(a)" by (rule allE)
have "∀x. Q(x)" using assms by (rule conjunct2)
then have "Q(a)" by (rule allE)
with ‹P(a)› show "P(a) ∧ Q(a)" by (rule conjI)
qed

― ‹La demostración estructurada es›
lemma ejemplo_6_2b:
assumes "(∀x. P(x)) ∧ (∀x. Q(x))"
shows "∀x. P(x) ∧ Q(x)"
proof
fix a
have "∀x. P(x)" using assms ..
then have "P(a)" by (rule allE)
have "∀x. Q(x)" using assms ..
then have "Q(a)" ..
with ‹P(a)› show "P(a) ∧ Q(a)" ..
qed

― ‹La demostración automática es›
lemma ejemplo_6_2c:
assumes "(∀x. P(x)) ∧ (∀x. Q(x))"
shows "∀x. P(x) ∧ Q(x)"
using assms
by auto

text ‹
Ejemplo 6.3 (p. 20). Demostrar
⊢ ∀x. P(x) ∧ Q(x) ⟷ (∀x. P(x)) ∧ (∀x. Q(x))›

― ‹La demostración detallada es›
lemma ejemplo_6_3a:
"(∀x. P(x) ∧ Q(x)) ⟷ ((∀x. P(x)) ∧ (∀x. Q(x)))"
proof (rule iffI)
assume "∀x. P(x) ∧ Q(x)"
then show "(∀x. P(x)) ∧ (∀x. Q(x))" by (rule ejemplo_6_1a)
next
assume "(∀x. P(x)) ∧ (∀x. Q(x))"
then show "∀x. P(x) ∧ Q(x)" by (rule ejemplo_6_2a)
qed

text ‹
Ejemplo 7.1 (p. 21). Demostrar
(∃x. P(x)) ∨ (∃x. Q(x)) ⊢ ∃x. P(x) ∨ Q(x)›

― ‹La demostración detallada es›
lemma ejemplo_7_1a:
assumes "(∃x. P(x)) ∨ (∃x. Q(x))"
shows "∃x. P(x) ∨ Q(x)"
using assms
proof (rule disjE)
assume "∃x. P(x)"
then obtain a where "P(a)" by (rule exE)
then have "P(a) ∨ Q(a)" by (rule disjI1)
then show "∃x. P(x) ∨ Q(x)" by (rule exI)
next
assume "∃x. Q(x)"
then obtain a where "Q(a)" by (rule exE)
then have "P(a) ∨ Q(a)" by (rule disjI2)
then show "∃x. P(x) ∨ Q(x)" by (rule exI)
qed

― ‹La demostración estructurada es›
lemma ejemplo_7_1b:
assumes "(∃x. P(x)) ∨ (∃x. Q(x))"
shows "∃x. P(x) ∨ Q(x)"
using assms
proof
assume "∃x. P(x)"
then obtain a where "P(a)" ..
then have "P(a) ∨ Q(a)" ..
then show "∃x. P(x) ∨ Q(x)" ..
next
assume "∃x. Q(x)"
then obtain a where "Q(a)" ..
then have "P(a) ∨ Q(a)" ..
then show "∃x. P(x) ∨ Q(x)" ..
qed

― ‹La demostración automática es›
lemma ejemplo_7_1c:
assumes "(∃x. P(x)) ∨ (∃x. Q(x))"
shows "∃x. P(x) ∨ Q(x)"
using assms
by auto

text ‹
Ejemplo 7.2 (p. 22). Demostrar
∃x. P(x) ∨ Q(x) ⊢ (∃x. P(x)) ∨ (∃x. Q(x))›

― ‹La demostración detallada es›
lemma ejemplo_7_2a:
assumes "∃x. P(x) ∨ Q(x)"
shows "(∃x. P(x)) ∨ (∃x. Q(x))"
proof -
obtain a where "P(a) ∨ Q(a)" using assms by (rule exE)
then show "(∃x. P(x)) ∨ (∃x. Q(x))"
proof (rule disjE)
assume "P(a)"
then have "∃x. P(x)" by (rule exI)
then show "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule disjI1)
next
assume "Q(a)"
then have "∃x. Q(x)" by (rule exI)
then show "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule disjI2)
qed
qed

― ‹La demostración estructurada es›
lemma ejercicio_7_2b:
assumes "∃x. P(x) ∨ Q(x)"
shows "(∃x. P(x)) ∨ (∃x. Q(x))"
proof -
obtain a where "P(a) ∨ Q(a)" using assms ..
then show "(∃x. P(x)) ∨ (∃x. Q(x))"
proof
assume "P(a)"
then have "∃x. P(x)" ..
then show "(∃x. P(x)) ∨ (∃x. Q(x))" ..
next
assume "Q(a)"
then have "∃x. Q(x)" ..
then show "(∃x. P(x)) ∨ (∃x. Q(x))" ..
qed
qed

― ‹La demostración automática es›
lemma ejercicio_7_2c:
assumes "∃x. P(x) ∨ Q(x)"
shows "(∃x. P(x)) ∨ (∃x. Q(x))"
using assms
by auto

text ‹
Ejemplo 7.3 (p. 23). Demostrar
⊢ ((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x))›

― ‹La demostración detallada es›
lemma ejemplo_7_3a:
"((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x))"
proof (rule iffI)
assume "(∃x. P(x)) ∨ (∃x. Q(x))"
then show "∃x. P(x) ∨ Q(x)" by (rule ejemplo_7_1a)
next
assume "∃x. P(x) ∨ Q(x)"
then show "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule ejemplo_7_2a)
qed

― ‹La demostración automática es›
lemma ejemplo_7_3b:
"((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x))"
using assms
by auto

text ‹
Ejemplo 8.1 (p. 24). Demostrar
∃x y. P(x,y) ⊢ ∃y x. P(x,y)›

― ‹La demostración detallada es›
lemma ejemplo_8_1a:
assumes "∃x y. P(x,y)"
shows "∃y x. P(x,y)"
proof -
obtain a where "∃y. P(a,y)" using assms by (rule exE)
then obtain b where "P(a,b)" by (rule exE)
then have "∃x. P(x,b)" by (rule exI)
then show "∃y x. P(x,y)" by (rule exI)
qed

― ‹La demostración estructurada es›
lemma ejemplo_8_1b:
assumes "∃x y. P(x,y)"
shows "∃y x. P(x,y)"
proof -
obtain a where "∃y. P(a,y)" using assms ..
then obtain b where "P(a,b)" ..
then have "∃x. P(x,b)" ..
then show "∃y x. P(x,y)" ..
qed

― ‹La demostración automática es›
lemma ejemplo_8_1c:
assumes "∃x y. P(x,y)"
shows "∃y x. P(x,y)"
using assms
by auto

text ‹
Ejemplo 8.2. Demostrar
∃y x. P(x,y) ⊢ ∃x y. P(x,y)›

― ‹La demostración detallada es›
lemma ejemplo_8_2a:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
proof -
obtain b where "∃x. P(x,b)" using assms by (rule exE)
then obtain a where "P(a,b)" by (rule exE)
then have "∃y. P(a,y)" by (rule exI)
then show "∃x y. P(x,y)" by (rule exI)
qed

― ‹La demostración estructurada es›
lemma ejemplo_8_2b:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
proof -
obtain b where "∃x. P(x,b)" using assms ..
then obtain a where "P(a,b)" ..
then have "∃y. P(a,y)" ..
then show "∃x y. P(x,y)" ..
qed

― ‹La demostración estructurada es›
lemma ejemplo_8_2c:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
using assms
by auto

text ‹
Ejemplo 8.3 (p. 25). Demostrar
⊢ (∃x y. P(x,y)) ⟷ (∃y x. P(x,y))›

― ‹La demostración detallada es›
lemma ejemplo_8_3a:
"(∃x y. P(x,y)) ⟷ (∃y x. P(x,y))"
proof (rule iffI)
assume "∃x y. P(x,y)"
then show "∃y x. P(x,y)" by (rule ejemplo_8_1a)
next
assume "∃y x. P(x,y)"
then show "∃x y. P(x,y)" by (rule ejemplo_8_2a)
qed

― ‹La demostración automática es›
lemma ejemplo_8_3b:
"(∃x y. P(x,y)) ⟷ (∃y x. P(x,y))"
by auto

section ‹Reglas de la igualdad›

text ‹
Las reglas básicas de la igualdad son:
· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
›

text ‹
Ejemplo 9 (p. 27). Demostrar
x + 1 = 1 + x, x + 1 > 1 ⟶ x + 1 > 0 ⊢ 1 + x > 1 ⟶ 1 + x > 0
›

― ‹La demostración detallada es›
lemma ejemplo_9a:
assumes "x + 1 = 1 + x"
"x + 1 > 1 ⟶ x + 1 > 0"
shows "1 + x > 1 ⟶ 1 + x > 0"
proof -
show "1 + x > 1 ⟶ 1 + x > 0" using assms by (rule subst)
qed

― ‹La demostración estructurada es›
lemma ejemplo_9b:
assumes "x + 1 = 1 + x"
"x + 1 > 1 ⟶ x + 1 > 0"
shows "1 + x > 1 ⟶ 1 + x > 0"
using assms
by (rule subst)

― ‹La demostración automática es›
lemma ejemplo_9c:
assumes "x + 1 = 1 + x"
"x + 1 > 1 ⟶ x + 1 > 0"
shows "1 + x > 1 ⟶ 1 + x > 0"
using assms
by auto

text ‹
Ejemplo 10 (p. 27). Demostrar
x = y, y = z ⊢ x = z
›

― ‹La demostración detallada es›
lemma ejemplo_10a:
assumes "x = y"
"y = z"
shows "x = z"
proof -
show "x = z" using assms(2,1) by (rule subst)
qed

― ‹La demostración estructurada es›
lemma ejemplo_10b:
assumes "x = y"
"y = z"
shows "x = z"
using assms(2,1)
by (rule subst)

― ‹La demostración automática es›
lemma ejemplo_10c:
assumes "x = y"
"y = z"
shows "x = z"
using assms
by auto

text ‹
Ejemplo 11 (p. 28). Demostrar
s = t ⊢ t = s
›

― ‹La demostración detallada es›
lemma ejemplo_11a:
assumes "s = t"
shows "t = s"
proof -
have "s = s" by (rule refl)
with assms show "t = s" by (rule subst)
qed

― ‹La demostración automática es›
lemma ejemplo_11b:
assumes "s = t"
shows "t = s"
using assms
by auto

end
</source>

Temas

2020-02-07T20:02:36Z

Jalonso:

En esta página se encuentra el material (transparencias y teorías) del curso ''Lógica matemática y fundamentos''.

* Tema 1: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-1.pdf Sintaxis y semántica de la lógica proposicional].
* Tema 2: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-2.pdf Deducción natural proposicional].
* Tema 2a: [[Deducción natural proposicional con Isabelle/HOL]].
* Tema 3: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-3.pdf Sintaxis y semántica de la lógica de primer orden].
* Tema 4: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-4.pdf Deducción natural en lógica de primer orden].
* Tema 4a: [https://www.glc.us.es/~jalonso/LMF2019/index.php/Tema_4a Deducción natural en lógica de primer orden con Isabelle/HOL].
* Tema 5: [[Programación funcional en Isabelle/HOL]].
* Tema 6: [https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8.pdf Razonamiento sobre programas].
* Tema 6a: [[Razonamiento sobre programas en Isabelle/HOL]].
* Tema 7: [[Razonamiento por casos y por inducci¢n]].
* Tema 8: [[Razonamiento sobre árboles y bosques]].
* Tema 9: [[Definiciones inductivas]].
* Tema 10: [[Conjuntos, funciones y relaciones]].
* Tema 11: [[Desarrollo de teorías formalizadas con Isabelle/HOL]].

Deducción natural proposicional con Isabelle/HOL

2020-02-07T20:02:03Z

Jalonso:

<source lang="isabelle">
chapter ‹Tema 2a: Deducción natural proposicional con Isabelle/HOL›

theory T2a_Deduccion_natural_en_logica_proposicional_con_Isabelle
imports Main
begin

text ‹En este tema se presentan los ejemplos del tema de deducción
natural proposicional siguiendo la presentación de Huth y Ryan en su
libro "Logic in Computer Science" http://goo.gl/qsVpY y, más
concretamente, a la forma como se explica en la asignatura de
"Lógica informática" (LI) http://goo.gl/AwDiv

La página al lado de cada ejemplo indica la página de las
transparencias de LI donde se encuentra la demostración.›

section ‹Reglas de la conjunción›

subsection ‹Ejemplo 1›

text ‹Ejemplo 1 (p. 4). Demostrar que
p ∧ q, r ⊢ q ∧ r.
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_1_1:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 by (rule conjunct2)
show 4: "q ∧ r" using 3 2 by (rule conjI)
qed

text ‹Notas sobre el lenguaje: En la demostración anterior se ha usado
· "assumes" para indicar las hipótesis,
· "and" para separar las hipótesis,
· "shows" para indicar la conclusión,
· "proof" para iniciar la prueba,
· "qed" para terminar la pruebas,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "using" para usar hechos en un paso,
· "by (rule ..)" para indicar la regla con la que se peueba un hecho,
· "show" para establecer la conclusión.

Notas sobre la lógica: Las reglas de la conjunción son
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
›

subsubsection ‹Demostración estructurada›

text ‹Se pueden dejar implícitas las reglas como sigue›

lemma ejemplo_1_2:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 ..
show 4: "q ∧ r" using 3 2 ..
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· ".." para indicar que se prueba por la regla correspondiente.›

text ‹Se pueden eliminar las etiquetas como sigue›

lemma ejemplo_1_3:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof -
have "q" using assms(1) ..
then show "q ∧ r" using assms(2) ..
qed

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms(n)" para indicar la hipótesis n y
· "then show" para demostrar la conclusión usando el hecho anterior.
Además, no es necesario usar and entre las hipótesis.›

subsubsection ‹Demostración automática›

text ‹Se puede automatizar la demostración como sigue›

lemma ejemplo_1_4:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms
by auto

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms" para indicar las hipótesis y
· "by auto" para demostrar la conclusión automáticamente.›

subsubsection ‹Demostración detallada hacia atrás›

text ‹Se puede hacer la demostración por razonamiento hacia atrás,
como sigue›

lemma ejemplo_1_5:
assumes "p ∧ q"
and "r"
shows "q ∧ r"
proof (rule conjI)
show "q" using assms(1) by (rule conjunct2)
next
show "r" using assms(2) by this
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "proof (rule r)" para indicar que se hará la demostración con la
regla r,
· "next" para indicar el comienzo de la prueba del siguiente
subobjetivo,
· "this" para indicar el hecho actual.›

subsubsection ‹Demostración estructurada hacia atrás›

text ‹Se pueden dejar implícitas las reglas como sigue›

lemma ejemplo_1_6:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof
show "q" using assms(1) ..
next
show "r" using assms(2) .
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "." para indicar por el hecho actual.›

subsubsection ‹Demostraciones automáticas›

lemma ejemplo_1_7:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms by simp

― ‹Se puede acortar como sigue›

― ‹La demostración automática es›
lemma ejemplo_1_8_:
"⟦p ∧ q; r⟧ ⟹ q ∧ r"
by simp

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· "⟦ ... ⟧" para representar las hipótesis,
· ";" para separar las hipótesis y
· "⟹" para separar las hipótesis de la conclusión.›

subsubsection ‹Demostración aplicativa›

― ‹La demostración aplicativa es›
lemma ejemplo_1_9:
"⟦p ∧ q; r⟧ ⟹ q ∧ r"
apply (rule conjI)
apply (erule conjunct2)
apply assumption
done

text ‹Explicaciones:
apply (rule conjI)
+ Objetivo: ⟦p ∧ q; r⟧ ⟹ q ∧ r
+ conjI: ⟦?P; ?Q⟧ ⟹ ?P ∧ ?Q
+ Unificador de q ∧ r
y ?P ∧ ?Q
es ?P/q, ?Q/r
+ Nuevos objetivos: ⟦p ∧ q; r⟧ ⟹ q
⟦p ∧ q; r⟧ ⟹ r

apply (erule conjunct2)
+ Objetivo: ⟦p ∧ q; r⟧ ⟹ q
+ conjunct2: ?P ∧ ?Q ⟹ ?Q
+ Unificador de p ∧ q
y ?P ∧ ?Q
es ?P/p, ?Q/q
+ Nuevo objetivo: Nada
›

section ‹Reglas de la doble negación›

subsection ‹Reglas de la doble negación›

text ‹La regla de eliminación de la doble negación es
· notnotD: ¬¬ P ⟹ P

Para ajustarnos al tema de LI vamos a introducir la siguiente regla de
introducción de la doble negación
· notnotI: P ⟹ ¬¬ P
aunque, de momento, no detallamos su demostración.
›

lemma notnotI [intro!]: "P ⟹ ¬¬ P"
by auto

subsection ‹Ejemplo 2›

text ‹Ejemplo 2. (p. 5)
p, ¬¬(q ∧ r) ⊢ ¬¬p ∧ r
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_2_1:
assumes 1: "p" and
2: "¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have 3: "¬¬p" using 1 by (rule notnotI)
have 4: "q ∧ r" using 2 by (rule notnotD)
have 5: "r" using 4 by (rule conjunct2)
show 6: "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

subsubsection ‹Demostración estructurada›

― ‹Se puede eliminar etiquetas y reglas›
lemma ejemplo_2_2:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have "¬¬p" using assms(1) ..
have "q ∧ r" using assms(2) by (rule notnotD)
then have "r" ..
with ‹¬¬p› show "¬¬p ∧ r" ..
qed

text ‹Nota sobre el lenguaje: En la demostración anterior se ha usado
· `...` para referenciar un hecho y
· "with P show Q" para indicar que con el hecho anterior junto con el
hecho P se demuestra Q.›

subsubsection ‹Demostración detallada hacia atrás›

text ‹Se puede demostrar hacia atrás›

lemma ejemplo_2_3:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof (rule conjI)
show "¬¬p" using assms(1) by (rule notnotI)
next
have "q ∧ r" using assms(2) by (rule notnotD)
then show "r" by (rule conjunct2)
qed

subsubsection ‹Demostración estructurada hacia atrás›

text ‹Se puede eliminar las reglas en la demostración anterior, como
sigue:›

lemma ejemplo_2_4:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof
show "¬¬p" using assms(1) ..
next
have "q ∧ r" using assms(2) by (rule notnotD)
then show "r" ..
qed

subsubsection ‹Demostraciones automáticas›

― ‹La demostración automática es›
lemma ejemplo_2_5:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
using assms
by simp

― ‹Se puede simplificar›
lemma ejemplo_2_6:
"⟦p; ¬¬(q ∧ r)⟧ ⟹ ¬¬p ∧ r"
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_2_7:
"⟦p; ¬¬(q ∧ r)⟧ ⟹ ¬¬p ∧ r"
apply (rule conjI)
apply (rule notnotI)
apply assumption
apply (drule notnotD)
apply (erule conjunct2)
done

text ‹Explicaciones:
apply (rule conjI)
+ Objetivo: ⟦p; ¬¬(q ∧ r)⟧ ⟹ ¬¬p ∧ r
+ conjI: ⟦?P; ?Q⟧ ⟹ ?P ∧ ?Q
+ Unificador de ¬¬p ∧ r
y ?P ∧ ?Q
es ?P/¬¬p, ?Q/r
+ Nuevos objetivos: ⟦p; ¬ ¬ (q ∧ r)⟧ ⟹ ¬ ¬ p
⟦p; ¬ ¬ (q ∧ r)⟧ ⟹ r

apply (rule notnotI)
+ Objetivo: ⟦p; ¬ ¬ (q ∧ r)⟧ ⟹ ¬ ¬ p
+ notnotI: ?P ⟹ ¬ ¬ ?P
+ Unificador de ¬ ¬ p
y ¬ ¬ ?P
es ?P/p
+ Nuevo objetivo: ⟦p; ¬ ¬ (q ∧ r)⟧ ⟹ p

apply (drule notnotD)
+ Objetivo: ⟦p; ¬ ¬ (q ∧ r)⟧ ⟹ r
+ notnotD: ¬ ¬ ?P ⟹ ?P
+ Unificador de ¬ ¬ (q ∧ r)
y ¬ ¬ ?P
es ?P/(q ∧ r)
+ Nuevo objetivo: ⟦p; q ∧ r⟧ ⟹ r

apply (erule conjunct2)
+ Objetivo: ⟦p; q ∧ r⟧ ⟹ r
+ conjunct2: ?P ∧ ?Q ⟹ ?Q
+ Unificador de q ∧ r
y ?P ∧ ?Q
es ?P/q, ?Q/r
+ Nuevo objetivo: Nada
›

section ‹Regla de eliminación del condicional›

text ‹La regla de eliminación del condicional es la regla del modus
ponens
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
›

subsection ‹Ejemplo 3›

text ‹Ejemplo 3. (p. 6) Demostrar que
¬p ∧ q, ¬p ∧ q ⟶ r ∨ ¬p ⊢ r ∨ ¬p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_3_1:
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_3_2:
assumes "¬p ∧ q"
"¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using assms(2,1) ..
qed

subsubsection ‹Demostración aplicativa›

lemma ejemplo_3_3:
"⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p"
apply (erule mp)
apply assumption
done

text ‹Explicaciones:
apply (erule mp)
+ Objetivo: ⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p
+ mp: ⟦?P ⟶ ?Q; ?P⟧ ⟹ ?Q
+ Unificador de ¬p ∧ q ⟶ r ∨ ¬p
y ?P ⟶ ?Q
es ?P/¬p ∧ q, ?Q/r ∨ ¬p
+ Nuevos objetivos: ¬ p ∧ q ⟹ ¬ p ∧ q
›

subsubsection ‹Demostración automática›

lemma ejemplo_3_4:
"⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p"
by simp

subsection ‹Ejemplo 4›

text ‹
Ejemplo 4 (p. 6) Demostrar que
p, p ⟶ q, p ⟶ (q ⟶ r) ⊢ r
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_4_1:
assumes 1: "p" and
2: "p ⟶ q" and
3: "p ⟶ (q ⟶ r)"
shows "r"
proof -
have 4: "q" using 2 1 by (rule mp)
have 5: "q ⟶ r" using 3 1 by (rule mp)
show 6: "r" using 5 4 by (rule mp)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_4_2:
assumes "p"
"p ⟶ q"
"p ⟶ (q ⟶ r)"
shows "r"
proof -
have "q" using assms(2,1) ..
have "q ⟶ r" using assms(3,1) ..
then show "r" using ‹q› ..
qed

subsubsection ‹Demostración aplicativa›

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

subsubsection ‹Demostración automática›

lemma ejemplo_4_4:
"⟦p; p ⟶ q; p ⟶ (q ⟶ r)⟧ ⟹ r"
by simp

section ‹Regla derivada del modus tollens›

text ‹Para ajustarnos al tema de LI vamos a introducir la regla del
modus tollens
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
aunque, de momento, sin detallar su demostración.›

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

subsection ‹Ejemplo 5›

text ‹Ejemplo 5 (p. 7). Demostrar
p ⟶ (q ⟶ r), p, ¬r ⊢ ¬q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_5_1:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof -
have 4: "q ⟶ r" using 1 2 by (rule mp)
show "¬q" using 4 3 by (rule mt)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_5_2:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
proof -
have "q ⟶ r" using assms(1,2) ..
then show "¬q" using assms(3) by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_5_3:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
using assms
by simp

lemma ejemplo_5_4:
"⟦p ⟶ (q ⟶ r); p; ¬r ⟧ ⟹ ¬q"
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_5_5:
"⟦p ⟶ (q ⟶ r); p; ¬r ⟧ ⟹ ¬q"
apply (drule mp)
apply assumption
apply (erule mt)
apply assumption
done

subsection ‹Ejemplo 6›

text ‹Ejemplo 6. (p. 7) Demostrar
¬p ⟶ q, ¬q ⊢ p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_6_1:
assumes 1: "¬p ⟶ q" and
2: "¬q"
shows "p"
proof -
have 3: "¬¬p" using 1 2 by (rule mt)
show "p" using 3 by (rule notnotD)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_6_2:
assumes "¬p ⟶ q"
"¬q"
shows "p"
proof -
have "¬¬p" using assms(1,2) by (rule mt)
then show "p" by (rule notnotD)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_6_3:
"⟦¬p ⟶ q; ¬q⟧ ⟹ p"
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_6_4:
"⟦¬p ⟶ q; ¬q⟧ ⟹ p"
apply (drule mt)
apply assumption
apply (erule notnotD)
done

subsection ‹Ejemplo 7›

text ‹Ejemplo 7. (p. 7) Demostrar
p ⟶ ¬q, q ⊢ ¬p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_7_1:
assumes 1: "p ⟶ ¬q" and
2: "q"
shows "¬p"
proof -
have 3: "¬¬q" using 2 by (rule notnotI)
show "¬p" using 1 3 by (rule mt)
qed

― ‹La demostración detallada es›
lemma ejemplo_7_2:
assumes "p ⟶ ¬q"
"q"
shows "¬p"
proof -
have "¬¬q" using assms(2) by (rule notnotI)
with assms(1) show "¬p" by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_7_3:
"⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_7_4:
"⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
apply (erule mt)
apply (erule notnotI)
done

section ‹Regla de introducción del condicional›

text ‹La regla de introducción del condicional es
· impI: (P ⟹ Q) ⟹ P ⟶ Q
›

subsection ‹Ejemplo 8›

text ‹ Ejemplo 8. (p. 8) Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_8_1:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 2: "¬q"
have "¬p" using 1 2 by (rule mt) }
then show "¬q ⟶ ¬p" by (rule impI)
qed

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "{ ... }" para representar una caja.›

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_8_2:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with assms show "¬p" by (rule mt)
qed

subsubsection ‹Demostración automática›

lemma ejemplo_8_3:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
using assms
by auto

subsubsection ‹Demostración automática›

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

subsection ‹Ejemplo 9›

text ‹Ejemplo 9. (p. 9) Demostrar
¬q ⟶ ¬p ⊢ p ⟶ ¬¬q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_9_1:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof -
{ assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt) }
then show "p ⟶ ¬¬q" by (rule impI)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_9_2:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof
assume "p"
then have "¬¬p" by (rule notnotI)
with assms show "¬¬q" by (rule mt)
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_9_3:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_9_4:
"¬q ⟶ ¬p ⟹ p ⟶ ¬¬q"
apply (rule impI)
apply (erule mt)
apply (rule notnotI)
apply assumption
done

subsection ‹Ejemplo 10›

text ‹Ejemplo 10 (p. 9). Demostrar
⊢ p ⟶ p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_10_1:
"p ⟶ p"
proof -
{ assume 1: "p"
have "p" using 1 by this }
then show "p ⟶ p" by (rule impI)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_10_2:
"p ⟶ p"
proof (rule impI)
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_10_3:
"p ⟶ p"
by simp

subsubsection ‹Demostración aplicativa›

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

subsection ‹Ejemplo 11›

text ‹Ejemplo 11 (p. 10) Demostrar
⊢ (q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_11_1:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof -
{ assume 1: "q ⟶ r"
{ assume 2: "¬q ⟶ ¬p"
{ assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
have "r" using 1 6 by (rule mp) }
then have "p ⟶ r" by (rule impI) }
then have "(¬q ⟶ ¬p) ⟶ p ⟶ r" by (rule impI) }
then show "(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ p ⟶ r)" by (rule impI)
qed

― ‹La demostración hacia atrás es›
lemma ejemplo_11_2:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 by (rule mp)
qed
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración hacia atrás con reglas implícitas es›
lemma ejemplo_11_3:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume 3: "p"
have 4: "¬¬p" using 3 ..
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 ..
qed
qed
qed

― ‹La demostración sin etiquetas es›
lemma ejemplo_11_4:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume "p"
then have "¬¬p" ..
with ‹¬q ⟶ ¬p› have "¬¬q" by (rule mt)
then have "q" by (rule notnotD)
with ‹q ⟶ r› show "r" ..
qed
qed
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_11_5:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_11_6:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
apply (rule impI)+
apply (erule mp)
apply (drule mt)
apply (rule notnotI)
apply assumption
apply (rule notnotD)
apply assumption
done

section ‹Reglas de la disyunción›

text ‹
Las reglas de la introducción de la disyunción son
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
La regla de elimación de la disyunción es
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
›

subsection ‹Ejemplo 12›

text ‹Ejemplo 12 (p. 11). Demostrar
p ∨ q ⊢ q ∨ p
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_12_1:
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

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "moreover" para separar los bloques y
· "ultimately" para unir los resultados de los bloques.›

subsubsection ‹Demostración estructurada›

― ‹La demostración detallada con reglas implícitas es›
lemma ejemplo_12_2:
assumes "p ∨ q"
shows "q ∨ p"
proof -
note ‹p ∨ q›
moreover
{ assume "p"
then have "q ∨ p" .. }
moreover
{ assume "q"
then have "q ∨ p" .. }
ultimately show "q ∨ p" ..
qed

text ‹
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "note" para copiar un hecho.›

subsubsection ‹Demostración detallada hacia atrás›

― ‹La demostración hacia atrás es›
lemma ejemplo_12_3:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1
proof (rule disjE)
{ assume 2: "p"
show "q ∨ p" using 2 by (rule disjI2) }
next
{ assume 3: "q"
show "q ∨ p" using 3 by (rule disjI1) }
qed

subsubsection ‹Demostración estructurada hacia atrás›

― ‹La demostración hacia atrás con reglas implícitas es›
lemma ejemplo_12_4:
assumes "p ∨ q"
shows "q ∨ p"
using assms
proof
{ assume "p"
then show "q ∨ p" .. }
next
{ assume "q"
then show "q ∨ p" .. }
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_12_5:
assumes "p ∨ q"
shows "q ∨ p"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_12_6:
"p ∨ q ⟹ q ∨ p"
apply (erule disjE)
apply (rule disjI2)
prefer 2
apply (rule disjI1)
apply assumption+
done

subsection ‹Ejemplo 13›

text ‹
Ejemplo 13. (p. 12) Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_13_1:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q"
then show "p ∨ r"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ r" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "r" using 1 4 by (rule mp)
show "p ∨ r" using 5 by (rule disjI2) }
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_13_2:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
then show "p ∨ r"
proof
{ assume "p"
then show "p ∨ r" .. }
next
{ assume "q"
have "r" using assms ‹q› ..
then show "p ∨ r" .. }
qed
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_13_3:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_13_4:
"q ⟶ r ⟹ p ∨ q ⟶ p ∨ r"
apply (rule impI)
apply (erule disjE)
apply (rule disjI1)
prefer 2
apply (drule mp)
prefer 2
apply (rule disjI2)
apply assumption+
done

section ‹Regla de copia›

subsection ‹Ejemplo 14›

text ‹Ejemplo 14 (p. 13). Demostrar
⊢ p ⟶ (q ⟶ p)
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_14_1:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using 1 by this
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_14_2:
"p ⟶ (q ⟶ p)"
proof
assume "p"
then show "q ⟶ p" ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_14_3:
"p ⟶ (q ⟶ p)"
by simp

subsubsection ‹Demostración aplicativa›

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

section ‹Reglas de la negación›

text ‹La regla de eliminación de lo falso es
· FalseE: False ⟹ P
La regla de eliminación de la negación es
· notE: ⟦¬P; P⟧ ⟹ R
La regla de introducción de la negación es
· notI: (P ⟹ False) ⟹ ¬P
›

subsection ‹Ejemplo 15›

text ‹Ejemplo 15 (p. 15). Demostrar
¬p ∨ q ⊢ p ⟶ q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_15_1:
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p"
note 1
then show "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume 4: "q"
show "q" using 4 by this}
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_15_2:
assumes "¬p ∨ q"
shows "p ⟶ q"
proof
assume "p"
note ‹¬p ∨ q›
then show "q"
proof
assume "¬p"
then show "q" using ‹p› ..
next
assume "q"
then show "q" .
qed
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_15_3:
assumes "¬p ∨ q"
shows "p ⟶ q"
using assms
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_15_4:
"¬p ∨ q ⟹ p ⟶ q"
apply (rule impI)
apply (erule disjE)
apply (erule notE)
apply assumption+
done

subsection ‹Ejemplo 16›

text ‹Ejemplo 16 (p. 16). Demostrar
p ⟶ q, p ⟶ ¬q ⊢ ¬p
›
subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_16_1:
assumes 1: "p ⟶ q" and
2: "p ⟶ ¬q"
shows "¬p"
proof (rule notI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "¬q" using 2 3 by (rule mp)
show False using 5 4 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_16_2:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
proof
assume "p"
have "q" using assms(1) ‹p› ..
have "¬q" using assms(2) ‹p› ..
then show False using ‹q› ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_16_3:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
using assms
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_16_4:
"⟦p ⟶ q; p ⟶ ¬q⟧ ⟹ ¬p"
apply (rule notI)
apply (drule mp)+
apply assumption+
apply (drule mp)
prefer 2
apply (erule notE)
apply assumption+
done

section ‹Reglas del bicondicional›

text ‹La regla de introducción del bicondicional es
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P ⟷ Q
Las reglas de eliminación del bicondicional son
· iffD1: ⟦Q ⟷ P; Q⟧ ⟹ P
· iffD2: ⟦P ⟷ Q; Q⟧ ⟹ P
›

subsection ‹Ejemplo 17›

text ‹Ejemplo 17 (p. 17) Demostrar
(p ∧ q) ⟷ (q ∧ p)
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_17_1:
"(p ∧ q) ⟷ (q ∧ p)"
proof (rule iffI)
{ assume 1: "p ∧ q"
have 2: "p" using 1 by (rule conjunct1)
have 3: "q" using 1 by (rule conjunct2)
show "q ∧ p" using 3 2 by (rule conjI) }
next
{ assume 4: "q ∧ p"
have 5: "q" using 4 by (rule conjunct1)
have 6: "p" using 4 by (rule conjunct2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_17_2:
"(p ∧ q) ⟷ (q ∧ p)"
proof
{ assume 1: "p ∧ q"
have "p" using 1 ..
have "q" using 1 ..
show "q ∧ p" using ‹q› ‹p› .. }
next
{ assume 2: "q ∧ p"
have "q" using 2 ..
have "p" using 2 ..
show "p ∧ q" using ‹p› ‹q› .. }
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_17_3:
"(p ∧ q) ⟷ (q ∧ p)"
by auto

subsubsection ‹Demostración aplicativa›

lemma ejemplo_17_4:
"(p ∧ q) ⟷ (q ∧ p)"
apply (rule iffI)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
done

subsection ‹Ejemplo 18›

text ‹Ejemplo 18 (p. 18). Demostrar
p ⟷ q, p ∨ q ⊢ p ∧ q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_18_1:
assumes 1: "p ⟷ q" and
2: "p ∨ q"
shows "p ∧ q"
using 2
proof (rule disjE)
{ assume 3: "p"
have 4: "q" using 1 3 by (rule iffD1)
show "p ∧ q" using 3 4 by (rule conjI) }
next
{ assume 5: "q"
have 6: "p" using 1 5 by (rule iffD2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_18_2:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms(2)
proof
{ assume "p"
with assms(1) have "q" ..
with ‹p› show "p ∧ q" .. }
next
{ assume "q"
with assms(1) have "p" ..
then show "p ∧ q" using ‹q› .. }
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_18_3:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_18_4:
"⟦p ⟷ q; p ∨ q⟧ ⟹ p ∧ q"
apply (erule disjE)
apply (rule conjI)
apply assumption
apply (erule iffD1)
apply assumption
apply (rule conjI)
apply (erule iffD2)
apply assumption+
done

section ‹Reglas derivadas›

subsection ‹Regla del modus tollens›

text ‹Ejemplo 19 (p. 20) Demostrar la regla del modus tollens a partir
de las reglas básicas.›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_20_1:
assumes 1: "F ⟶ G" and
2: "¬G"
shows "¬F"
proof (rule notI)
assume 3: "F"
have 4: "G" using 1 3 by (rule mp)
show False using 2 4 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_20_2:
assumes "F ⟶ G"
"¬G"
shows "¬F"
proof
assume "F"
with assms(1) have "G" ..
with assms(2) show False ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_20_3:
assumes "F ⟶ G"
"¬G"
shows "¬F"
using assms
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_20_4:
"⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
apply (rule notI)
apply (drule mp)
apply assumption
apply (erule notE)
apply assumption
done

subsection ‹Regla de la introducción de la doble negación›

text ‹Ejemplo 21 (p. 21) Demostrar la regla de introducción de la doble
negación a partir de las reglas básicas.›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_21_1:
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_21_2:
assumes "F"
shows "¬¬F"
proof
assume "¬F"
then show False using assms ..
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_21_3:
assumes "F"
shows "¬¬F"
using assms
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_21_4:
"F ⟹ ¬¬F"
apply (rule notI)
apply (erule notE)
apply assumption
done

subsection ‹Regla de reducción al absurdo›

text ‹La regla de reducción al absurdo en Isabelle se correponde con la
regla clásica de contradicción
· ccontr: (¬P ⟹ False) ⟹ P
›

subsection ‹Ley del tercio excluso›

text ‹La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
›

text ‹Ejemplo 22 (p. 23). Demostrar la ley del tercio excluso a partir de
las reglas básicas.›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_22_1:
"F ∨ ¬F"
proof (rule ccontr)
assume 1: "¬(F ∨ ¬F)"
then show False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume 2: "F"
then have 3: "F ∨ ¬F" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
qed
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_22_2:
"F ∨ ¬F"
proof (rule ccontr)
assume "¬(F ∨ ¬F)"
then show False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume "F"
then have "F ∨ ¬F" ..
with ‹¬(F ∨ ¬F)›show False ..
qed
qed
qed
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_22_3:
"F ∨ ¬F"
using assms
by simp

subsection ‹Ejemplo 23›

text ‹Ejemplo 23 (p. 24). Demostrar
p ⟶ q ⊢ ¬p ∨ q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_23_1:
assumes 1: "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
then show "¬p ∨ q"
proof (rule disjE)
{ assume "¬p"
then show "¬p ∨ q" by (rule disjI1) }
next
{ assume 2: "p"
have "q" using 1 2 by (rule mp)
then show "¬p ∨ q" by (rule disjI2) }
qed
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_23_2:
assumes "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" ..
then show "¬p ∨ q"
proof
{ assume "¬p"
then show "¬p ∨ q" .. }
next
{ assume "p"
with assms have "q" ..
then show "¬p ∨ q" .. }
qed
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_23_3:
assumes "p ⟶ q"
shows "¬p ∨ q"
using assms
by simp

subsubsection ‹Demostración aplicativa›

lemma ejemplo_23_4:
"p ⟶ q ⟹ ¬p ∨ q"
apply (cut_tac P="p" in excluded_middle)
apply (erule disjE)
apply (rule disjI1)
prefer 2
apply (drule mp)
prefer 2
apply (rule disjI2)
apply assumption+
done

section ‹Demostraciones por contradicción›

subsection ‹Ejemplo 24›

text ‹Ejemplo 24. Demostrar que
¬p, p ∨ q ⊢ q
›

subsubsection ‹Demostración detallada›

― ‹La demostración detallada es›
lemma ejemplo_24_1:
assumes "¬p"
"p ∨ q"
shows "q"
using ‹p ∨ q›
proof (rule disjE)
assume "p"
with assms(1) show "q" by contradiction
next
assume "q"
then show "q" by assumption
qed

subsubsection ‹Demostración estructurada›

― ‹La demostración estructurada es›
lemma ejemplo_24_2:
assumes "¬p"
"p ∨ q"
shows "q"
using ‹p ∨ q›
proof
assume "p"
with assms(1) show "q" ..
next
assume "q"
then show "q" .
qed

subsubsection ‹Demostración automática›

― ‹La demostración automática es›
lemma ejemplo_24_3:
assumes "¬p"
"p ∨ q"
shows "q"
using assms
by simp

subsubsection ‹Demostración aplicativa›

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

end
</source>

Examen 4

2019-09-11T11:13:00Z

Jalonso:

<source lang="isabelle">
text ‹Examen de Lógica Matemática y Fundamentos (10 septiembre 2019)›

theory examen_4_10_sep_sol
imports Main
begin

text ‹Nota: En las demostraciones se pueden 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_middle: (¬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⟧ ⟹ c = 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

También se pueden usar 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. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
((p ⟶ r) ∨ (q ⟶ s)) ⟶ ((p ∧ q) ⟶ (r ∨ s))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración aplicativa *)
lemma "((p ⟶ r) ∨ (q ⟶ s)) ⟶ ((p ∧ q) ⟶ (r ∨ s))"
proof
assume 1: "(p ⟶ r) ∨ (q ⟶ s)"
show "(p ∧ q) ⟶ (r ∨ s)"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
have "q" using `p ∧ q` by (rule conjunct2)
note 1
then show "r ∨ s"
proof
assume "p ⟶ r"
then have "r" using `p` by (rule mp)
then show "r ∨ s" by (rule disjI1)
next
assume "q ⟶ s"
then have "s" using `q` by (rule mp)
then show "r ∨ s" by (rule disjI2)
qed
qed
qed

(* Demostración aplicativa. *)
lemma "((p ⟶ r) ∨ (q ⟶ s)) ⟶ ((p ∧ q) ⟶ (r ∨ s))"
apply (rule impI)+
apply (erule disjE)
apply (rule disjI1)
apply (erule mp)
apply (erule conjunct1)
apply (rule disjI2)
apply (erule mp)
apply (erule conjunct2)
done

text ‹-----------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Demostrar por deducción natural que la
fórmula ∀x. (∃y. ((P(x,y) ∨ Q(x,x)))) es consecuencia
lógica de ∀x. (P(x,x) ∨ ∀y. Q(x,y)).

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración declarativa. *)
lemma
assumes "∀x. (P(x,x) ∨ (∀y. Q(x,y)))"
shows "∀x. (∃y. (P(x,y) ∨ Q(x,x)))"
proof
fix a
have "P(a,a) ∨ (∀y. Q(a,y))" using assms by (rule allE)
then show "∃y. (P(a,y) ∨ Q(a,a))"
proof
assume "P(a,a)"
then have "P(a,a) ∨ Q(a,a)" by (rule disjI1)
then show "∃y. (P(a,y) ∨ Q(a,a))" by (rule exI)
next
assume "∀y. Q(a,y)"
then have "Q(a,a)" by (rule allE)
then have "P(a,a) ∨ Q(a,a)" by (rule disjI2)
then show "∃y. (P(a,y) ∨ Q(a,a))" by (rule exI)
qed
qed

(* Demostración aplicativa. *)
lemma "⟦∀x. (P(x,x) ∨ (∀y. Q(x,y)))⟧ ⟹ ∀x. (∃y. (P(x,y) ∨ Q(x,x)))"
apply (rule allI)
apply (erule_tac x = x in allE)
apply (erule disjE)
apply (rule_tac x = x in exI)
apply (rule disjI1, simp)
apply (erule_tac x = x in allE)
apply (rule_tac x = x in exI)
apply (rule disjI2, simp)
done

text ‹-----------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario
definido por
datatype 'a arbol = H
| N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Se define las funciones
fun nNodos :: "'a arbol ⇒ nat" where
"nNodos H = 0"
| "nNodos (N x i d) = 1 + nNodos i + nNodos d"

fun nNodosAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nNodosAaux H n = n"
| "nNodosAaux (N x i d) n = 1 + nNodosAaux i (nNodosAaux d n)"

definition nNodosA :: "'a arbol ⇒ nat" where
"nNodosA a ≡ nNodosAaux a 0"
tales que
+ (nNodos a) es el número de nodos del árbol a. Por ejemplo,
nNodos (N e (N c H H) (N g H H)) = 3
+ (nNodosAA a) es el número de nodos del árbol a, calculado
con la función auxiliar nNodosAaux que usa un acumulador. Por
ejemplo,
nNodosA (N e (N c H H) (N g H H)) = 3

Demostrar estructuradamente (es decir, mediante una demostración
declarativa) que las funciones nNodos y nNodosA son equivalentes;
es decir,
nNodosA a = nNodos a

Notas:
1. Los únicos métodos que se pueden usar son induct, (simp only: ...)
y this.
2. En las demostraciones por introducción del cuantificador universal
hay que explicitar el tipo de las variables introducidas con fix.
Por ejemplo, en lugar de
fix x t n
hay que escribir
fix x :: 'a and t :: "'a arbol" and and n :: nat
-------------------------------------------------------------------›

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

fun nNodos :: "'a arbol ⇒ nat" where
"nNodos H = 0"
| "nNodos (N x i d) = 1 + nNodos i + nNodos d"

fun nNodosAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nNodosAaux H n = n"
| "nNodosAaux (N x i d) n = 1 + nNodosAaux i (nNodosAaux d n)"

definition nNodosA :: "'a arbol ⇒ nat" where
"nNodosA a ≡ nNodosAaux a 0"

value "nNodos (N e (N c H H) (N g H H)) = 3"
value "nNodosA (N e (N c H H) (N g H H)) = 3"

(* Demostración declarativa. *)
lemma nNodosA:
"nNodosAaux a n = (nNodos a) + n"
proof (induct a arbitrary: n)
fix n
have "nNodosAaux H n = n" by (simp only: nNodosAaux.simps(1))
also have "… = nNodos H + n" by (simp only: nNodos.simps(1))
finally show "nNodosAaux H n = nNodos H + n" by this
next
fix x :: 'a and
i :: "'a arbol" and
d :: "'a arbol" and
n :: nat
assume HI1: "⋀n. nNodosAaux i n = nNodos i + n"
and HI2: "⋀n. nNodosAaux d n = nNodos d + n"
have "nNodosAaux (N x i d) n = 1 + nNodosAaux i (nNodosAaux d n)"
by (simp only: nNodosAaux.simps(2))
also have "… = 1 + nNodosAaux i (nNodos d + n)"
by (simp only: HI2)
also have "… = 1 + nNodos i + (nNodos d + n)"
by (simp only: HI1)
also have "… = nNodos (N x i d) + n"
by (simp only: nNodos.simps(2))
finally show "nNodosAaux (N x i d) n = nNodos (N x i d) + n"
by this
qed

(* Demostración aplicativa del lema anterior *)
lemma "nNodosAaux a n = (nNodos a) + n"
apply (induct a arbitrary: n)
apply (simp only: nNodosAaux.simps(1))
apply (simp only: nNodos.simps(1))
apply (simp only: nNodosAaux.simps(2))
apply (simp only: nNodos.simps(2))
done

lemma "nNodosA a = nNodos a"
proof -
have "nNodosA a = nNodosAaux a 0" by (simp only: nNodosA_def)
also have "… = (nNodos a)" by (simp only: nNodosA)
finally show "nNodosA a = nNodos a" by this
qed

text ‹---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Demostrar que si en un grupo se cumple la siguente
propiedad cancelativa
∀x. ∀y. ∀z. x ⋅ y = z ⋅ x ⟶ y = z
entonces el grupo es abeliano.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis

Nota: Los únicos métodos que se pueden usar son (simp only: ...) o
rule.
------------------------------------------------------------------›

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

(* Demostración declarativa. *)
lemma
assumes "∀x. ∀y. ∀z. x ⋅ y = z ⋅ x ⟶ y = z"
shows "∀x. ∀y. x ⋅ y = y ⋅ x"
proof (rule allI)+
fix a b
have "b ⋅ (a ⋅ b) = (b ⋅ a) ⋅ b ⟶ a ⋅ b = b ⋅ a"
proof -
have "∀y. ∀z. b ⋅ y = z ⋅ b ⟶ y = z" using assms by (rule allE)
then have "∀z. b ⋅ (a ⋅ b) = z ⋅ b ⟶ a ⋅ b = z" by (rule allE)
then show "b ⋅ (a ⋅ b) = (b ⋅ a) ⋅ b ⟶ a ⋅ b = b ⋅ a" by (rule allE)
qed
moreover
have "b ⋅ (a ⋅ b) = (b ⋅ a) ⋅ b" by (simp only: asociativa)
ultimately show "a ⋅ b = b ⋅ a" by (rule mp)
qed

(* Demostración aplicativa. *)
lemma
"⟦∀x. ∀y. ∀z. x ⋅ y = z ⋅ x ⟶ y = z⟧ ⟹
∀x. ∀y. x ⋅ y = y ⋅ x"
apply (rule allI)+
apply (erule_tac x = y in allE)
apply (erule_tac x = "x ⋅ y" in allE)
apply (erule_tac x = "y ⋅ x" in allE)
apply (erule mp)
apply (simp add: asociativa)
done

end

end
</source>

Examen 3

2019-07-08T15:39:59Z

Jalonso:

<source lang="isabelle">text ‹Examen de Lógica Matemática y Fundamentos (5 julio 2019)›

theory examen_3_05_jul_sol
imports Main
begin

text ‹Nota: En las demostraciones se pueden 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_middle: (¬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⟧ ⟹ c = 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

También se pueden usar 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. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
p ∨ (q ⟶ ¬(p ⟷ q))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración declarativa. *)
lemma "p ∨ (q ⟶ ¬(p ⟷ q))"
proof -
have "¬p ∨ p" by (rule excluded_middle)
then show "p ∨ (q ⟶ ¬(p ⟷ q))"
proof
assume "¬p"
have "q ⟶ ¬(p ⟷ q)"
proof
assume "q"
show "¬(p ⟷ q)"
proof
assume "p ⟷ q"
then have "p" using `q` by (rule iffD2)
with `¬p` show False by (rule notE)
qed
qed
then show "p ∨ (q ⟶ ¬(p ⟷ q))" by (rule disjI2)
next
assume "p"
then show "p ∨ (q ⟶ ¬(p ⟷ q))" by (rule disjI1)
qed
qed

(* Demostración aplicativa. *)
lemma "p ∨ (q ⟶ ¬(p ⟷ q))"
apply (case_tac "p")
apply (erule disjI1)
apply (rule disjI2)
apply (rule impI)
apply (rule notI)
apply (drule iffD2)
apply assumption
apply (erule notE)
apply assumption
done

text ‹-----------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Se puede formalizar la teoría de las tallas
usando los siguientes símbolos
P x representa que x es de la talla pequeña
M x representa que x es de la talla mediana
G x representa que x es de la talla grande
Mayor x y representa que la talla de x es mayor que la de y.

Los axiomas de las tallas son
∃x. P x
∃x. M x
∃x. G x
∀x y. G x ∧ M y ⟶ Mayor x y
∀x y. M x ∧ P y ⟶ Mayor x y
∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z
∀x. ¬(Mayor x x)

Demostrar detalladamente que la fórmula
∀x. ¬(P x) ∨ ¬(M x)
es consecuencia de los axiomas de las tallas.

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración declarativa *)
lemma
assumes "∃x. P x"
"∃x. M x"
"∃x. G x"
"∀x y. G x ∧ M y ⟶ Mayor x y"
"∀x y. M x ∧ P y ⟶ Mayor x y"
"∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z"
"∀x. ¬(Mayor x x)"
shows "∀x. ¬(P x) ∨ ¬(M x)"
proof
fix a
have "¬(P a) ∨ P a" by (rule excluded_middle)
then show "¬(P a) ∨ ¬(M a)"
proof
assume "¬(P a)"
then show "¬(P a) ∨ ¬(M a)" by (rule disjI1)
next
assume "P a"
have "~(M a)"
proof
assume "M a"
have "~(Mayor a a)" using assms(7) by (rule allE)
moreover
have "Mayor a a"
proof -
have "∀y. M a ∧ P y ⟶ Mayor a y" using assms(5) by (rule allE)
then have "M a ∧ P a ⟶ Mayor a a" by (rule allE)
moreover
have "M a ∧ P a" using `M a` `P a` by (rule conjI)
ultimately show "Mayor a a" by (rule mp)
qed
ultimately show False by (rule notE)
qed
then show "¬ P a ∨ ¬ M a" by (rule disjI2)
qed
qed

(* Demostración aplicativa *)
lemma "⟦∃x. P x;
∃x. M x;
∃x. G x;
∀x y. M x ∧ P y ⟶ Mayor x y;
∀x y. G x ∧ M y ⟶ Mayor x y;
∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z;
∀x. ¬(Mayor x x)⟧⟹
∀x. ¬(P x) ∨ ¬(M x)"
apply (rule allI)
apply (case_tac "P x")
prefer 2
apply (rule disjI1, assumption)
apply (rule disjI2)
apply (rule notI)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule notE)
apply (drule mp)
apply (rule conjI, assumption+)
done

text ‹-----------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario definido por
datatype 'a arbol = H
| N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Se define las funciones
fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = nHojas i + nHojas d"

fun nHojasAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nHojasAaux H n = n + 1"
| "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"

definition nHojasA :: "'a arbol ⇒ nat" where
"nHojasA a ≡ nHojasAaux a 0"
tales que
+ (nHojas a) es el número de hojas del árbol a. Por ejemplo,
nHojas (N e (N c H H) (N g H H)) = 4
+ (nHojasAA a) es el número de hojas del árbol a, calculado
con la función auxiliar nHojasAaux que usa un acumulador. Por
ejemplo,
nHojasA (N e (N c H H) (N g H H)) = 4

Demostrar estructuradamente (es decir, mediante una demostración
declarativa) que las funciones nHojas y nHojasA son equivalentes;
es decir,
nHojasA a = nHojas a

Notas:
1. Los únicos métodos que se pueden usar son induct, (simp only: ...)
y this.
2. En las demostraciones por introducción del cuantificador universal
hay que explicitar el tipo de las variables introducidas con fix.
Por ejemplo, en lugar de
fix x t n
hay que escribir
fix x :: 'a and t :: "'a arbol" and and n :: nat
-------------------------------------------------------------------›

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

fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = nHojas i + nHojas d"

fun nHojasAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nHojasAaux H n = n + 1"
| "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"

definition nHojasA :: "'a arbol ⇒ nat" where
"nHojasA a ≡ nHojasAaux a 0"

value "nHojas (N e (N c H H) (N g H H)) = 4"
value "nHojasA (N e (N c H H) (N g H H)) = 4"

lemma nHojasA:
"nHojasAaux a n = (nHojas a) + n"
proof (induct a arbitrary: n)
fix n
have "nHojasAaux H n = n + 1" by (simp only: nHojasAaux.simps(1))
also have "… = nHojas H + n" by (simp only: nHojas.simps(1))
finally show "nHojasAaux H n = nHojas H + n" by this
next
fix x :: 'a and
i :: "'a arbol" and
d :: "'a arbol" and
n :: nat
assume HI1: "⋀n. nHojasAaux i n = nHojas i + n"
and HI2: "⋀n. nHojasAaux d n = nHojas d + n"
have "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"
by (simp only: nHojasAaux.simps(2))
also have "… = nHojasAaux i (nHojas d + n)"
by (simp only: HI2)
also have "… = nHojas i + (nHojas d + n)"
by (simp only: HI1)
also have "… = nHojas (N x i d) + n"
by (simp only: nHojas.simps(2))
finally show "nHojasAaux (N x i d) n = nHojas (N x i d) + n"
by this
qed

(* Demostración aplicativa del lema anterior *)
lemma "nHojasAaux a n = (nHojas a) + n"
apply (induct a arbitrary: n)
apply (simp only: nHojasAaux.simps(1))
apply (simp only: nHojas.simps(1))
apply (simp only: nHojasAaux.simps(2))
apply (simp only: nHojas.simps(2))
done

lemma "nHojasA a = nHojas a"
proof -
have "nHojasA a = nHojasAaux a 0" by (simp only: nHojasA_def)
also have "… = (nHojas a)" by (simp only: nHojasA)
finally show "nHojasA a = nHojas a" by this
qed

text ‹---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Demostrar detalladamente que los grupos
booleanos son conmutativos; es decir, si G un grupo tal que
x ⋅ x = 1
para todo x de G, entonces
x ⋅ y = y ⋅ x
para todo x, y de G.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis

Nota: Los únicos métodos que se pueden usar son (simp only: ...) o
rule.
------------------------------------------------------------------›

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

(* Una demostración declarativa es *)
lemma
assumes "∀x. x ⋅ x = 𝟭"
shows "∀x. ∀y. x ⋅ y = y ⋅ x"
proof (rule allI)+
fix a b
show "a ⋅ b = b ⋅ a"
proof -
have "(b ⋅ a) ⋅ (b ⋅ a) = 𝟭" by (simp only: assms)
then have "b ⋅ ((b ⋅ a) ⋅ (b ⋅ a)) = b ⋅ 𝟭" by (rule arg_cong)
then have "b ⋅ ((b ⋅ a) ⋅ (b ⋅ a)) = b" by (simp only: neutro_d)
then have "(b ⋅ b) ⋅ (a ⋅ (b ⋅ a)) = b" by (simp only: asociativa)
then have "𝟭 ⋅ (a ⋅ (b ⋅ a)) = b" by (simp only: assms)
then have "a ⋅ (b ⋅ a) = b" by (simp only: neutro_i)
then have "(a ⋅ (b ⋅ a)) ⋅ a = b ⋅ a" by (rule arg_cong)
then have "(a ⋅ b) ⋅ (a ⋅ a) = b ⋅ a" by (simp only: asociativa)
then have "(a ⋅ b) ⋅ 𝟭 = b ⋅ a" by (simp only: assms)
then show "a ⋅ b = b ⋅ a" by (simp only: neutro_d)
qed
qed

end

end
</source>

Examen 3

2019-07-08T10:33:31Z

Jalonso:

Examen 3

2019-07-08T10:31:08Z

Jalonso:

<source lang="isabelle">text ‹Examen de Lógica Matemática y Fundamentos (5 julio 2019)›

theory examen_3_05_jul_sol
imports Main
begin

text ‹Nota: En las demostraciones se pueden 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_middle: (¬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⟧ ⟹ c = 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

También se pueden usar 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. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
p ∨ (q ⟶ ¬(p ⟷ q))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración declarativa. *)
lemma "p ∨ (q ⟶ ¬(p ⟷ q))"
proof -
have "¬p ∨ p" by (rule excluded_middle)
then show "p ∨ (q ⟶ ¬(p ⟷ q))"
proof
assume "¬p"
have "q ⟶ ¬(p ⟷ q)"
proof
assume "q"
show "¬(p ⟷ q)"
proof
assume "p ⟷ q"
then have "p" using `q` by (rule iffD2)
with `¬p` show False by (rule notE)
qed
qed
then show "p ∨ (q ⟶ ¬(p ⟷ q))" by (rule disjI2)
next
assume "p"
then show "p ∨ (q ⟶ ¬(p ⟷ q))" by (rule disjI1)
qed
qed

(* Demostración aplicativa. *)
lemma "p ∨ (q ⟶ ¬(p ⟷ q))"
apply (case_tac "p")
apply (erule disjI1)
apply (rule disjI2)
apply (rule impI)
apply (rule notI)
apply (drule iffD2)
apply assumption
apply (erule notE)
apply assumption
done

text ‹-----------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Se puede formalizar la teoría de las tallas
usando los siguientes símbolos
P x representa que x es de la talla pequeña
M x representa que x es de la talla mediana
G x representa que x es de la talla grande
Mayor x y representa que la talla de x es mayor que la de y.

Los axiomas de las tallas son
∃x. P x
∃x. M x
∃x. G x
∀x y. G x ∧ M y ⟶ Mayor x y
∀x y. M x ∧ P y ⟶ Mayor x y
∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z
∀x. ¬(Mayor x x)"

Demostrar detalladamente que la fórmula
∀x. ¬(P x) ∨ ¬(M x)
es consecuencia de los axiomas de las tallas.

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
--------------------------------------------------------------------›

(* Demostración declarativa *)
lemma
assumes "∃x. P x"
"∃x. M x"
"∃x. G x"
"∀x y. G x ∧ M y ⟶ Mayor x y"
"∀x y. M x ∧ P y ⟶ Mayor x y"
"∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z"
"∀x. ¬(Mayor x x)"
shows "∀x. ¬(P x) ∨ ¬(M x)"
proof
fix a
have "¬(P a) ∨ P a" by (rule excluded_middle)
then show "¬(P a) ∨ ¬(M a)"
proof
assume "¬(P a)"
then show "¬(P a) ∨ ¬(M a)" by (rule disjI1)
next
assume "P a"
have "~(M a)"
proof
assume "M a"
have "~(Mayor a a)" using assms(7) by (rule allE)
moreover
have "Mayor a a"
proof -
have "∀y. M a ∧ P y ⟶ Mayor a y" using assms(5) by (rule allE)
then have "M a ∧ P a ⟶ Mayor a a" by (rule allE)
moreover
have "M a ∧ P a" using `M a` `P a` by (rule conjI)
ultimately show "Mayor a a" by (rule mp)
qed
ultimately show False by (rule notE)
qed
then show "¬ P a ∨ ¬ M a" by (rule disjI2)
qed
qed

(* Demostración aplicativa *)
lemma "⟦∃x. P x;
∃x. M x;
∃x. G x;
∀x y. M x ∧ P y ⟶ Mayor x y;
∀x y. G x ∧ M y ⟶ Mayor x y;
∀x y z . Mayor x y ∧ Mayor y z ⟶ Mayor x z;
∀x. ¬(Mayor x x)⟧⟹
∀x. ¬(P x) ∨ ¬(M x)"
apply (rule allI)
apply (case_tac "P x")
prefer 2
apply (rule disjI1, assumption)
apply (rule disjI2)
apply (rule notI)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule_tac x = x in allE)
apply (erule notE)
apply (drule mp)
apply (rule conjI, assumption+)
done

text ‹-----------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario definido por
datatype 'a arbol = H
| N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Se define las funciones
fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = nHojas i + nHojas d"

fun nHojasAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nHojasAaux H n = n + 1"
| "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"

definition nHojasA :: "'a arbol ⇒ nat" where
"nHojasA a ≡ nHojasAaux a 0"
tales que
+ (nHojas a) es el número de hojas del árbol a. Por ejemplo,
nHojas (N e (N c H H) (N g H H)) = 4
+ (nHojasAA a) es el número de hojas del árbol a, calculado
con la función auxiliar nHojasAaux que usa un acumulador. Por
ejemplo,
nHojasA (N e (N c H H) (N g H H)) = 4

Demostrar estructuradamente (es decir, mediante una demostración
declarativa) que las funciones nHojas y nHojasA son equivalentes;
es decir,
nHojasA a = nHojas a

Notas:
1. Los únicos métodos que se pueden usar son induct, (simp only: ...)
y this.
2. En las demostraciones por introducción del cuantificador universal
hay que explicitar el tipo de las variables introducidas con fix.
Por ejemplo, en lugar de
fix x t n
hay que escribir
fix x :: 'a and t :: "'a arbol" and and n :: nat
-------------------------------------------------------------------›

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

fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = nHojas i + nHojas d"

fun nHojasAaux :: "'a arbol ⇒ nat ⇒ nat" where
"nHojasAaux H n = n + 1"
| "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"

definition nHojasA :: "'a arbol ⇒ nat" where
"nHojasA a ≡ nHojasAaux a 0"

value "nHojas (N e (N c H H) (N g H H)) = 4"
value "nHojasA (N e (N c H H) (N g H H)) = 4"

lemma nHojasA:
"nHojasAaux a n = (nHojas a) + n"
proof (induct a arbitrary: n)
fix n
have "nHojasAaux H n = n + 1" by (simp only: nHojasAaux.simps(1))
also have "… = nHojas H + n" by (simp only: nHojas.simps(1))
finally show "nHojasAaux H n = nHojas H + n" by this
next
fix x :: 'a and
i :: "'a arbol" and
d :: "'a arbol" and
n :: nat
assume HI1: "⋀n. nHojasAaux i n = nHojas i + n"
and HI2: "⋀n. nHojasAaux d n = nHojas d + n"
have "nHojasAaux (N x i d) n = nHojasAaux i (nHojasAaux d n)"
by (simp only: nHojasAaux.simps(2))
also have "… = nHojasAaux i (nHojas d + n)"
by (simp only: HI2)
also have "… = nHojas i + (nHojas d + n)"
by (simp only: HI1)
also have "… = nHojas (N x i d) + n"
by (simp only: nHojas.simps(2))
finally show "nHojasAaux (N x i d) n = nHojas (N x i d) + n"
by this
qed

(* Demostración aplicativa del lema anterior *)
lemma "nHojasAaux a n = (nHojas a) + n"
apply (induct a arbitrary: n)
apply (simp only: nHojasAaux.simps(1))
apply (simp only: nHojas.simps(1))
apply (simp only: nHojasAaux.simps(2))
apply (simp only: nHojas.simps(2))
done

lemma "nHojasA a = nHojas a"
proof -
have "nHojasA a = nHojasAaux a 0" by (simp only: nHojasA_def)
also have "… = (nHojas a)" by (simp only: nHojasA)
finally show "nHojasA a = nHojas a" by this
qed

text ‹---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Demostrar detalladamente que los grupos
booleanos son conmutativos; es decir, si G un grupo tal que
x ⋅ x = 1
para todo x de G, entonces
x ⋅ y = y ⋅ x
para todo x, y de G.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis

Nota: Los únicos métodos que se pueden usar son (simp only: ...) o
rule.
------------------------------------------------------------------›

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

(* Una demostración declarativa es *)
lemma
assumes "∀x. x ⋅ x = 𝟭"
shows "∀x. ∀y. x ⋅ y = y ⋅ x"
proof (rule allI)+
fix a b
show "a ⋅ b = b ⋅ a"
proof -
have "(b ⋅ a) ⋅ (b ⋅ a) = 𝟭" by (simp only: assms)
then have "b ⋅ ((b ⋅ a) ⋅ (b ⋅ a)) = b ⋅ 𝟭" by (rule arg_cong)
then have "b ⋅ ((b ⋅ a) ⋅ (b ⋅ a)) = b" by (simp only: neutro_d)
then have "(b ⋅ b) ⋅ (a ⋅ (b ⋅ a)) = b" by (simp only: asociativa)
then have "𝟭 ⋅ (a ⋅ (b ⋅ a)) = b" by (simp only: assms)
then have "a ⋅ (b ⋅ a) = b" by (simp only: neutro_i)
then have "(a ⋅ (b ⋅ a)) ⋅ a = b ⋅ a" by (rule arg_cong)
then have "(a ⋅ b) ⋅ (a ⋅ a) = b ⋅ a" by (simp only: asociativa)
then have "(a ⋅ b) ⋅ 𝟭 = b ⋅ a" by (simp only: assms)
then show "a ⋅ b = b ⋅ a" by (simp only: neutro_d)
qed
qed

end

end
</source>

Sol 12

2019-06-26T17:06:29Z

Jalonso:

<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

(* 1ª demostración: sin patrones *)
lemma "preOrden (espejo a) = rev (postOrden a)"
proof (induct a)
fix x :: 'a
show "preOrden (espejo (H x)) = rev (postOrden (H x))" by simp
next
fix x :: 'a and i d :: "'a arbol"
assume HI1: "preOrden (espejo i) = rev (postOrden i)"
assume HI2: "preOrden (espejo d) = rev (postOrden d)"
show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))"
proof -
have "preOrden (espejo (N x i d)) =
preOrden (N x (espejo d) (espejo i))" by simp
also have "… = [x] @ preOrden (espejo d) @ preOrden (espejo i)"
by simp
also have "… = rev [x] @ rev (postOrden d) @ rev (postOrden i)"
using HI1 HI2 by simp
also have "… = rev ((postOrden i) @ (postOrden d) @ [x])" by simp
finally show ?thesis by simp
qed
qed

(* 2ª demostración: con patrones *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) =
preOrden (N x (espejo d) (espejo i))" by simp
also have "… = [x] @ preOrden (espejo d) @ preOrden (espejo i)"
by simp
also have "… = rev [x] @ rev (postOrden d) @ rev (postOrden i)"
using HI1 HI2 by simp
also have "… = rev ((postOrden i) @ (postOrden d) @ [x])" 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

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>

Examen 2

2019-06-26T15:08:46Z

Jalonso:

<source lang="isabelle">
chapter {* Examen de Lógica Matemática y Fundamentos (6 junio 2019) *}

theory examen_2_06_jun_sol
imports Main
begin

text {*
Apellidos:
Nombre:
*}

text {* Sustituye la palabra uvus por tu usuario de la Universidad de
Sevilla y graba el fichero con dicho usuario .thy
*}

text {*
Nota: En las demostraciones se pueden 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_middle: (¬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⟧ ⟹ c = 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

También se pueden usar 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. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
(p ⟶ q) ⟶((¬p ⟶ q) ⟶ q)

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

(* La demostración declarativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
proof
assume "p ⟶ q"
show "(¬p ⟶ q) ⟶ q"
proof
assume "¬p ⟶ q"
have "¬p ∨ p" by (rule excluded_middle)
then show "q"
proof (rule disjE)
assume "¬p"
with `¬p ⟶ q` show q by (rule mp)
next
assume "p"
with `p ⟶ q` show q by (rule mp)
qed
qed
qed

(* Una demostración aplicativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
apply (rule impI)+
(* ⟦p ⟶ q; ¬ p ⟶ q⟧ ⟹ q *)
apply (cut_tac P=p in excluded_middle)
(* ⟦p ⟶ q; ¬ p ⟶ q; ¬ p ∨ p⟧ ⟹ q *)
apply (erule disjE)
(* 1. ⟦p ⟶ q; ¬ p ⟶ q; ¬ p⟧ ⟹ q
2. ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply (erule_tac P="¬p" in mp)
(* 1. ⟦p ⟶ q; ¬ p⟧ ⟹ ¬ p
2. ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply assumption
(* ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply (erule mp)
(* ⟦¬ p ⟶ q; p⟧ ⟹ p *)
apply assumption
(* *)
done

(* Otra demostración aplicativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
apply (rule impI)+
(* ⟦p ⟶ q; ¬ p ⟶ q⟧ ⟹ q *)
apply (rule ccontr)
(* ⟦p ⟶ q; ¬ p ⟶ q; ¬ q⟧ ⟹ False *)
apply (drule_tac G=q in mt)
(* 1. ⟦¬ p ⟶ q; ¬ q⟧ ⟹ ¬ q
2. ⟦¬ p ⟶ q; ¬ q; ¬ p⟧ ⟹ False *)
apply assumption
(* ⟦¬ p ⟶ q; ¬ q; ¬ p⟧ ⟹ False *)
apply (erule notE)
(* ⟦¬ p ⟶ q; ¬ p⟧ ⟹ q *)
apply (erule mp)
(* ¬ p ⟹ ¬ p *)
apply assumption
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Demostrar detalladamente que si R es una
relación irreflexiva y transitiva, entonces R es antisimétrica.
{ ∀x. ¬R(x,x),
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z)) }
⊢ ∀x. ∀y. (R(x,y) ⟶ ¬R(y,x))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

(* La demostración declarativa es *)
lemma
assumes "∀x. ¬R(x,x)"
"∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))"
shows "∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
proof
fix a
show "∀y. (R(a,y) ⟶ ¬R(y,a))"
proof
fix b
show "R(a,b) ⟶ ¬R(b,a)"
proof
assume "R(a,b)"
show "¬ R(b,a)"
proof
assume "R(b,a)"
then have "R(b,a) ∧ R(a,b)" using `R(a,b)` by (rule conjI)
have "∀y. ∀z.(R(b,y) ∧ R(y,z) ⟶ R(b,z))"
using assms(2) by (rule allE)
then have "∀z.(R(b,a) ∧ R(a,z) ⟶ R(b,z))" by (rule allE)
then have "R(b,a) ∧ R(a,b) ⟶ R(b,b)" by (rule allE)
then have "R(b,b)" using `R(b,a) ∧ R(a,b)` by (rule mp)
have "¬R(b,b)" using assms(1) by (rule allE)
then show False using `R(b,b)` by (rule notE)
qed
qed
qed
qed

(* La demostración aplicativa es *)
lemma
"⟦ ∀x. ¬R(x,x);
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))⟧
⟹ ∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
apply (rule allI)+
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ R (x, y) ⟶ ¬ R (y, x)*)
apply (rule impI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y)⟧
⟹ ¬ R (y, x) *)
apply (rule notI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ ∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x);
¬ R (x, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=y in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ False *)
apply (erule notE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ R (x, x) *)
apply (drule mp)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y) ∧ R (y, x)
2. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x) *)
apply (rule conjI)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y)
2. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (y, x)
3. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x)*)
apply assumption+
(* *)
done

text {*
---------------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario definido por
datatype 'a arbol = H | N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Definir las funciones
nNodos :: "'a arbol ⇒ nat"
nHojas :: "'a arbol ⇒ nat"
tales que
+ (nNodos a) es el número de nodos de a. Por ejemplo,
nNodos (N e (N c H H) (N g H H)) = 3
+ (nHojas a) es el número de hojas de a. Por ejemplo,
nHojas (N e (N c H H) (N g H H)) = 4

Demostrar detalladamente que el número de hojas de un árbol es igual
al número de nodos más 1.

Nota: Los únicos métodos que se pueden usar son induct,
(simp only: ...) o this.
------------------------------------------------------------------- *}

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

fun nNodos :: "'a arbol ⇒ nat" where
"nNodos H = 0"
| "nNodos (N x i d) = 1 + (nNodos i) + (nNodos d)"

fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = (nHojas i) + (nHojas d)"

(* Demostración declarativa *)
lemma "nHojas a = (nNodos a) + 1" (is "?P a")
proof (induct a)
show "?P H" by (simp only: nHojas.simps(1) nNodos.simps(1))
next
fix x :: 'a and
i :: "'a arbol" and
d :: "'a arbol"
assume HI1: "?P i"
assume HI2: "?P d"
show "?P (N x i d)"
proof -
have "nHojas (N x i d) = (nHojas i) + (nHojas d)"
by (simp only: nHojas.simps(2))
also have "... = (nNodos i + 1) + (nNodos d + 1)"
by (simp only: HI1 HI2)
also have "... = (nNodos (N x i d)) + 1"
by (simp only: nNodos.simps(2))
finally show "?P (N x i d)" by this
qed
qed

(* Demostración aplicativa *)
lemma "nHojas a = (nNodos a) + 1"
apply (induct a)
(* 1. nHojas H = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(1))
(* 1. 1 = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) = nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(1))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(2))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nNodos a1 + 1 + (nNodos a2 + 1) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(2))
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Sea G un grupo. Domostrar detalladamente que
para todo par de elementos x e y de G, si x es el inverso de y,
entonces y es el inverso de x.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis
------------------------------------------------------------------ *}

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

(* Una demostración declarativa es *)
lemma "∀x. ∀y. x = y^ ⟶ y = x^"
proof (rule allI)+
fix a b
show "a = b^ ⟶ b = a^"
proof
assume "a = b^"
then have "a^ ⋅ a = a^ ⋅ b^" by simp
then have "𝟭 = a^ ⋅ b^" by (simp only: inverso_i)
then have "𝟭 ⋅ b = (a^ ⋅ b^) ⋅ b" by simp
then have "b = (a^ ⋅ b^) ⋅ b" by (simp only: neutro_i)
then have "b = a^ ⋅ (b^ ⋅ b)" by (simp only: asociativa)
then have "b = a^ ⋅ 𝟭" by (simp only: inverso_i)
then show "b = a^ " by (simp only: neutro_d)
qed
qed

(* Otra demostración declarativa es *)
lemma "∀x. ∀y. x = y^ ⟶ y = x^"
proof (rule allI)+
fix a b
show "a = b^ ⟶ b = a^"
proof
assume "a = b^"
show "b = a^"
proof -
have "b = 𝟭 ⋅ b" by (simp only: neutro_i)
also have "… = (a^ ⋅ a) ⋅ b" by (simp only: inverso_i)
also have "… = a^ ⋅ (a ⋅ b)" by (simp only: asociativa)
also have "… = a^ ⋅ (b^ ⋅ b)" using `a = b^` by simp
also have "… = a^ ⋅ 𝟭" by (simp only: inverso_i)
also have "… = a^" by (simp only: neutro_d)
finally show "b = a^" by this
qed
qed
qed

(* Demostración aplicativa *)
lemma aux1: "x = y ⟹ z ⋅ x = z ⋅ y "
by simp

lemma aux2: "x = y ⟹ x ⋅ z = y ⋅ z "
by simp

lemma aux3: "x = y^ ⟶ y = x^"
apply (rule impI)
(* x = y^ ⟹ y = x^ *)
apply (drule aux1[where ?z = "x^"])
(* x^ ⋅ x = x^ ⋅ y^ ⟹ y = x^ *)
apply (simp only: inverso_i)
(* 𝟭 = x^ ⋅ y^ ⟹ y = x^ *)
apply (drule aux2[where ?z = "y"])
(* 𝟭 ⋅ y = (x^ ⋅ y^) ⋅ y ⟹ y = x^ *)
apply (simp only: neutro_i)
(* y = (x^ ⋅ y^) ⋅ y ⟹ y = x^ *)
apply (simp only: asociativa)
(* y = x^ ⋅ (y^ ⋅ y) ⟹ y = x^ *)
apply (simp only: inverso_i)
(* y = x^ ⋅ 𝟭 ⟹ x^ ⋅ 𝟭 = x^ *)
apply (simp only: neutro_d)
(* *)
done

lemma "∀x. ∀y. x = y^ ⟶ y = x^"
apply (rule allI)+
apply (rule aux3)
done

end

end
</source>

Examen 2

2019-06-13T15:35:53Z

Jalonso:

<source lang="isabelle">
chapter {* Examen de Lógica Matemática y Fundamentos (6 junio 2019) *}

text {*
Nota: En las demostraciones se pueden 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_middle: (¬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⟧ ⟹ c = 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

También se pueden usar 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. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
(p ⟶ q) ⟶((¬p ⟶ q) ⟶ q)

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

(* La demostración declarativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
proof
assume "p ⟶ q"
show "(¬p ⟶ q) ⟶ q"
proof
assume "¬p ⟶ q"
have "¬p ∨ p" by (rule excluded_middle)
then show "q"
proof (rule disjE)
assume "¬p"
with `¬p ⟶ q` show q by (rule mp)
next
assume "p"
with `p ⟶ q` show q by (rule mp)
qed
qed
qed

(* Una demostración aplicativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
apply (rule impI)+
(* ⟦p ⟶ q; ¬ p ⟶ q⟧ ⟹ q *)
apply (cut_tac P=p in excluded_middle)
(* ⟦p ⟶ q; ¬ p ⟶ q; ¬ p ∨ p⟧ ⟹ q *)
apply (erule disjE)
(* 1. ⟦p ⟶ q; ¬ p ⟶ q; ¬ p⟧ ⟹ q
2. ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply (erule_tac P="¬p" in mp)
(* 1. ⟦p ⟶ q; ¬ p⟧ ⟹ ¬ p
2. ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply assumption
(* ⟦p ⟶ q; ¬ p ⟶ q; p⟧ ⟹ q *)
apply (erule mp)
(* ⟦¬ p ⟶ q; p⟧ ⟹ p *)
apply assumption
(* *)
done

(* Otra demostración aplicativa es *)
lemma "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
apply (rule impI)+
(* ⟦p ⟶ q; ¬ p ⟶ q⟧ ⟹ q *)
apply (rule ccontr)
(* ⟦p ⟶ q; ¬ p ⟶ q; ¬ q⟧ ⟹ False *)
apply (drule_tac G=q in mt)
(* 1. ⟦¬ p ⟶ q; ¬ q⟧ ⟹ ¬ q
2. ⟦¬ p ⟶ q; ¬ q; ¬ p⟧ ⟹ False *)
apply assumption
(* ⟦¬ p ⟶ q; ¬ q; ¬ p⟧ ⟹ False *)
apply (erule notE)
(* ⟦¬ p ⟶ q; ¬ p⟧ ⟹ q *)
apply (erule mp)
(* ¬ p ⟹ ¬ p *)
apply assumption
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Demostrar detalladamente que si R es una
relación irreflexiva y transitiva, entonces R es antisimétrica.
{ ∀x. ¬R(x,x),
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z)) }
⊢ ∀x. ∀y. (R(x,y) ⟶ ¬R(y,x))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

(* La demostración declarativa es *)
lemma
assumes "∀x. ¬R(x,x)"
"∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))"
shows "∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
proof
fix a
show "∀y. (R(a,y) ⟶ ¬R(y,a))"
proof
fix b
show "R(a,b) ⟶ ¬R(b,a)"
proof
assume "R(a,b)"
show "¬ R(b,a)"
proof
assume "R(b,a)"
then have "R(b,a) ∧ R(a,b)" using `R(a,b)` by (rule conjI)
have "∀y. ∀z.(R(b,y) ∧ R(y,z) ⟶ R(b,z))"
using assms(2) by (rule allE)
then have "∀z.(R(b,a) ∧ R(a,z) ⟶ R(b,z))" by (rule allE)
then have "R(b,a) ∧ R(a,b) ⟶ R(b,b)" by (rule allE)
then have "R(b,b)" using `R(b,a) ∧ R(a,b)` by (rule mp)
have "¬R(b,b)" using assms(1) by (rule allE)
then show False using `R(b,b)` by (rule notE)
qed
qed
qed
qed

(* La demostración aplicativa es *)
lemma
"⟦ ∀x. ¬R(x,x);
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))⟧
⟹ ∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
apply (rule allI)+
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ R (x, y) ⟶ ¬ R (y, x)*)
apply (rule impI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y)⟧
⟹ ¬ R (y, x) *)
apply (rule notI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ ∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x);
¬ R (x, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=y in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ False *)
apply (erule notE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ R (x, x) *)
apply (drule mp)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y) ∧ R (y, x)
2. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x) *)
apply (rule conjI)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y)
2. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (y, x)
3. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x)*)
apply assumption+
(* *)
done

text {*
---------------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario definido por
datatype 'a arbol = H | N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Definir las funciones
nNodos :: "'a arbol ⇒ nat"
nHojas :: "'a arbol ⇒ nat"
tales que
+ (nNodos a) es el número de nodos de a. Por ejemplo,
nNodos (N e (N c H H) (N g H H)) = 3
+ (nHojas a) es el número de hojas de a. Por ejemplo,
nHojas (N e (N c H H) (N g H H)) = 4

Demostrar detalladamente que el número de hojas de un árbol es igual
al número de nodos más 1.

Nota: Los únicos métodos que se pueden usar son induct,
(simp only: ...) o this.
------------------------------------------------------------------- *}

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

fun nNodos :: "'a arbol ⇒ nat" where
"nNodos H = 0"
| "nNodos (N x i d) = 1 + (nNodos i) + (nNodos d)"

fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = (nHojas i) + (nHojas d)"

(* Demostración declarativa *)
lemma "nHojas a = (nNodos a) + 1" (is "?P a")
proof (induct a)
show "?P H" by (simp only: nHojas.simps(1) nNodos.simps(1))
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
show "?P (N x i d)"
proof -
have "nHojas (N x i d) = (nHojas i) + (nHojas d)"
by (simp only: nHojas.simps(2))
also have "... = (nNodos i + 1) + (nNodos d + 1)"
by (simp only: HI1 HI2)
also have "... = (nNodos (N x i d)) + 1"
by (simp only: nNodos.simps(2))
finally show "?P (N x i d)" by this
qed
qed

(* Demostración aplicativa *)
lemma "nHojas a = (nNodos a) + 1"
apply (induct a)
(* 1. nHojas H = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(1))
(* 1. 1 = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) = nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(1))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(2))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nNodos a1 + 1 + (nNodos a2 + 1) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(2))
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Sea G un grupo. Domostrar detalladamente que
para todo par de elementos x e y de G, si x es el inverso de y,
entonces y es el inverso de x.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis
------------------------------------------------------------------ *}

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

(* Una demostración declarativa es *)
lemma "∀x. ∀y. x = y^ ⟶ y = x^"
proof (rule allI)+
fix a b
show "a = b^ ⟶ b = a^"
proof
assume "a = b^"
then have "a^ ⋅ a = a^ ⋅ b^" by simp
then have "𝟭 = a^ ⋅ b^" by (simp only: inverso_i)
then have "𝟭 ⋅ b = (a^ ⋅ b^) ⋅ b" by simp
then have "b = (a^ ⋅ b^) ⋅ b" by (simp only: neutro_i)
then have "b = a^ ⋅ (b^ ⋅ b)" by (simp only: asociativa)
then have "b = a^ ⋅ 𝟭" by (simp only: inverso_i)
then show "b = a^ " by (simp only: neutro_d)
qed
qed

(* Otra demostración declarativa es *)
lemma "∀x. ∀y. x = y^ ⟶ y = x^"
proof (rule allI)+
fix a b
show "a = b^ ⟶ b = a^"
proof
assume "a = b^"
show "b = a^"
proof -
have "b = 𝟭 ⋅ b" by (simp only: neutro_i)
also have "… = (a^ ⋅ a) ⋅ b" by (simp only: inverso_i)
also have "… = a^ ⋅ (a ⋅ b)" by (simp only: asociativa)
also have "… = a^ ⋅ (b^ ⋅ b)" using `a = b^` by simp
also have "… = a^ ⋅ 𝟭" by (simp only: inverso_i)
also have "… = a^" by (simp only: neutro_d)
finally show "b = a^" by this
qed
qed
qed

(* Demostración aplicativa *)
lemma aux1: "x = y ⟹ z ⋅ x = z ⋅ y "
by simp

lemma aux2: "x = y ⟹ x ⋅ z = y ⋅ z "
by simp

lemma aux3: "x = y^ ⟶ y = x^"
apply (rule impI)
(* x = y^ ⟹ y = x^ *)
apply (drule aux1[where ?z = "x^"])
(* x^ ⋅ x = x^ ⋅ y^ ⟹ y = x^ *)
apply (simp only: inverso_i)
(* 𝟭 = x^ ⋅ y^ ⟹ y = x^ *)
apply (drule aux2[where ?z = "y"])
(* 𝟭 ⋅ y = (x^ ⋅ y^) ⋅ y ⟹ y = x^ *)
apply (simp only: neutro_i)
(* y = (x^ ⋅ y^) ⋅ y ⟹ y = x^ *)
apply (simp only: asociativa)
(* y = x^ ⋅ (y^ ⋅ y) ⟹ y = x^ *)
apply (simp only: inverso_i)
(* y = x^ ⋅ 𝟭 ⟹ x^ ⋅ 𝟭 = x^ *)
apply (simp only: neutro_d)
(* *)
done

lemma "∀x. ∀y. x = y^ ⟶ y = x^"
apply (rule allI)+
apply (rule aux3)
done

end

end
</source>

Examen 2

2019-06-12T17:42:22Z

Jalonso:

Examen 2

2019-06-12T15:20:57Z

Jalonso:

<source lang="isabelle">
chapter {* Examen de Lógica Matemática y Fundamentos (6-junio-2919) *}

theory examen_2_06_jun_sol
imports Main
begin

text {* ---------------------------------------------------------------
Ejercicio 1. (2.5 puntos) Demostrar detalladamente que la siguiente
fórmula es una tautología:
(p ⟶ q) ⟶((¬p ⟶ q) ⟶ q)

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

lemma ej1:
shows "(p ⟶ q) ⟶ ((¬p ⟶ q) ⟶ q)"
proof
assume "p ⟶ q"
show "(¬p ⟶ q) ⟶ q"
proof
assume "¬p ⟶ q"
have "¬p ∨ p" by (rule excluded_middle)
then show "q"
proof (rule disjE)
assume "¬p"
with `¬p ⟶ q` show q by (rule mp)
next
assume "p"
with `p ⟶ q` show q by (rule mp)
qed
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 2. (2.5 puntos) Demostrar detalladamente que si R es una
relación irreflexiva y transitiva, entonces R es antisimétrica.
{ ∀x. ¬R(x,x),
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z)) }
⊢ ∀x. ∀y. (R(x,y) ⟶ ¬R(y,x))

Nota: No usar ninguno de los métodos automáticos: simp, simp_all,
auto, blast, force, fast, arith o metis
------------------------------------------------------------------ *}

(* La demostración declarativa es *)
lemma
assumes "∀x. ¬R(x,x)"
"∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))"
shows "∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
proof
fix a
show "∀y. (R(a,y) ⟶ ¬R(y,a))"
proof
fix b
show "R(a,b) ⟶ ¬R(b,a)"
proof
assume "R(a,b)"
show "¬ R(b,a)"
proof
assume "R(b,a)"
then have "R(b,a) ∧ R(a,b)" using `R(a,b)` by (rule conjI)
have "∀y. ∀z.(R(b,y) ∧ R(y,z) ⟶ R(b,z))"
using assms(2) by (rule allE)
then have "∀z.(R(b,a) ∧ R(a,z) ⟶ R(b,z))" by (rule allE)
then have "R(b,a) ∧ R(a,b) ⟶ R(b,b)" by (rule allE)
then have "R(b,b)" using `R(b,a) ∧ R(a,b)` by (rule mp)
have "¬R(b,b)" using assms(1) by (rule allE)
then show False using `R(b,b)` by (rule notE)
qed
qed
qed
qed

(* La demostración aplicativa es *)
lemma
"⟦ ∀x. ¬R(x,x);
∀x. ∀y. ∀z. (R(x,y) ∧ R(y,z) ⟶ R(x,z))⟧
⟹ ∀x. ∀y. (R(x,y) ⟶ ¬ R(y,x))"
apply (rule allI)+
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ R (x, y) ⟶ ¬ R (y, x)*)
apply (rule impI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y)⟧
⟹ ¬ R (y, x) *)
apply (rule notI)
(* ⋀x y. ⟦ ∀x. ¬ R (x, x);
∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ ∀x y z. R (x, y) ∧ R (y, z) ⟶ R (x, z);
R (x, y);
R (y, x);
¬ R (x, x)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀y z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=y in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
∀z. R (x, y) ∧ R (y, z) ⟶ R (x, z)⟧
⟹ False *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
¬ R (x, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ False *)
apply (erule notE)
(* ⋀x y. ⟦ R (x, y);
R (y, x);
R (x, y) ∧ R (y, x) ⟶ R (x, x)⟧
⟹ R (x, x) *)
apply (drule mp)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y) ∧ R (y, x)
2. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x) *)
apply (rule conjI)
(* 1. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (x, y)
2. ⋀x y. ⟦R (x, y); R (y, x)⟧ ⟹ R (y, x)
3. ⋀x y. ⟦R (x, y); R (y, x); R (x, x)⟧ ⟹ R (x, x)*)
apply assumption+
(* *)
done

text {*
---------------------------------------------------------------------
Ejercicio 3 (2.5 puntos) Consideremos el árbol binario definido por
datatype 'a arbol = H | N "'a" "'a arbol" "'a arbol"

Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \

se representa por "N e (N c H H) (N g H H)".

Definir las funciones
nNodos :: "'a arbol ⇒ nat"
nHojas :: "'a arbol ⇒ nat"
tales que
+ (nNodos a) es el número de nodos de a. Por ejemplo,
nNodos (N e (N c H H) (N g H H)) = 3
+ (nHojas a) es el número de hojas de a. Por ejemplo,
nHojas (N e (N c H H) (N g H H)) = 4

Demostrar detalladamente que el número de hojas de un árbol es igual
al número de nodos más 1.

Nota: Los únicos métodos que se pueden usar son induct,
(simp only: ...) o this.
------------------------------------------------------------------- *}

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

fun nNodos :: "'a arbol ⇒ nat" where
"nNodos H = 0"
| "nNodos (N x i d) = 1 + (nNodos i) + (nNodos d)"

fun nHojas :: "'a arbol ⇒ nat" where
"nHojas H = 1"
| "nHojas (N x i d) = (nHojas i) + (nHojas d)"

(* Demostración declarativa *)
lemma ej3:
"nHojas a = (nNodos a) + 1" (is "?P a")
proof (induct a)
show "?P H" by (simp only: nHojas.simps(1) nNodos.simps(1))
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
show "?P (N x i d)"
proof -
have "nHojas (N x i d) = (nHojas i) + (nHojas d)"
by (simp only: nHojas.simps(2))
also have "... = (nNodos i + 1) + (nNodos d + 1)"
by (simp only: HI1 HI2)
also have "... = (nNodos (N x i d)) + 1"
by (simp only: nNodos.simps(2))
finally show "?P (N x i d)" by this
qed
qed

(* Demostración aplicativa *)
lemma ej3_b:
"nHojas a = (nNodos a) + 1"
apply (induct a)
(* 1. nHojas H = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(1))
(* 1. 1 = nNodos H + 1
2. ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) = nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(1))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nHojas (N x1 a1 a2) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nHojas.simps(2))
(* ⋀x1 a1 a2. ⟦ nHojas a1 = nNodos a1 + 1;
nHojas a2 = nNodos a2 + 1⟧
⟹ nNodos a1 + 1 + (nNodos a2 + 1) =
nNodos (N x1 a1 a2) + 1 *)
apply (simp only: nNodos.simps(2))
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 4. (2.5 puntos) Sea G un grupo. Domostrar detalladamente que
para todo par de elementos x e y de G, si x es el inverso de y,
entonces y es el inverso de x.

Nota: No usar ninguno de los métodos automáticos: auto, blast, force,
fast, arith o metis
------------------------------------------------------------------ *}

locale grupo =
fixes prod :: "['a, 'a] ⇒ 'a" (infixl "⋅" 70)
and neutro ("𝟭")
and inverso ("_^" [100] 100)
assumes asociativa: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"
and neutro_i: "𝟭 ⋅ x = x"
and neutro_d: "x ⋅ 𝟭 = x"
and inverso_i: "x^ ⋅ x = 𝟭"

(* Notas sobre notación:
* El producto es ⋅ y se escribe con \ cdot (sin espacio entre ellos).
* El neutro es 𝟭 y se escribe con \ y one (sin espacio entre ellos).
* El inverso de x es x^ y se escribe pulsando 2 veces en ^. *)

context grupo
begin

lemma ej5:
shows "∀x. ∀y. x = y^ ⟶ y = x^"
proof (rule allI)+
fix a b
show "a = b^ ⟶ b = a^"
proof
assume "a = b^"
then have "a^ ⋅ a = a^ ⋅ b^" by simp
then have "𝟭 = a^ ⋅ b^" by (simp only: inverso_i)
then have "𝟭 ⋅ b = (a^ ⋅ b^) ⋅ b" by simp
then have "b = (a^ ⋅ b^) ⋅ b" by (simp only: neutro_i)
then have "b = a^ ⋅ (b^ ⋅ b)" by (simp only: asociativa)
then have "b = a^ ⋅ 𝟭" by (simp only: inverso_i)
then show "b = a^ " by (simp only: neutro_d)
qed
qed

end

end
</source>

Ejercicios

2019-06-06T13:52:37Z

Jalonso:

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]]).

Conjuntos, funciones y relaciones

2019-05-29T14:53:19Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 10: Conjuntos, funciones y relaciones *}

theory T10_Conjuntos_funciones_y_relaciones
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

text {*
Nota. La teoría elemental de conjuntos es HOL/Set.thy.

Nota. En un conjunto todos los elemento son del mismo tipo (por
ejemplo, del tipo τ) y el conjunto tiene tipo (en el ejemplo, "τ set").

Reglas de la intersección:
· IntI: ⟦c ∈ A; c ∈ B⟧ ⟹ c ∈ A ∩ B
· IntD1: c ∈ A ∩ B ⟹ c ∈ A
· IntD2: c ∈ A ∩ B ⟹ c ∈ B

Nota. Propiedades del complementario:
· Compl_iff: (c ∈ - A) = (c ∉ A)
· Compl_Un: - (A ∪ B) = - A ∩ - B

Nota. El conjunto vacío se representa por {} y el universal por UNIV.

Nota. Propiedades de la diferencia y del complementario:
· Diff_disjoint: A ∩ (B - A) = {}
· Compl_partition: A ∪ - A = UNIV

Nota. Reglas de la relación de subconjunto:
· subsetI: (⋀x. x ∈ A ⟹ x ∈ B) ⟹ A ⊆ B
· subsetD: ⟦A ⊆ B; c ∈ A⟧ ⟹ c ∈ B
*}

text {*
Ejemplo: A ∪ B ⊆ C syss A ⊆ C ∧ B ⊆ C.
*}

lemma "(A ∪ B ⊆ C) = (A ⊆ C ∧ B ⊆ C)"
by simp

text {*
Ejemplo: A ⊆ -B syss B ⊆ -A.
*}

lemma "(A ⊆ -B) = (B ⊆ -A)"
by auto

text {*
Principio de extensionalidad de conjuntos:
· set_eqI: (⋀x. (x ∈ A) = (x ∈ B)) ⟹ A = B

Reglas de la igualdad de conjuntos:
· equalityI: ⟦A ⊆ B; B ⊆ A⟧ ⟹ A = B
· equalityD1: A = B ⟹ A ⊆ B
· equalityD2: A = B ⟹ B ⊆ A
· equalityE: ⟦A = B; ⟦A ⊆ B; B ⊆ A⟧ ⟹ P⟧ ⟹ P
*}

text {*
Lema. [Analogía entre intersección y conjunción]
"x ∈ A ∩ B" syss "x ∈ A" y "x ∈ B".
*}

lemma "(x ∈ A ∩ B) = (x ∈ A ∧ x ∈ B)"
by simp

text {*
Lema. [Analogía entre unión y disyunción]
x ∈ A ∪ B syss x ∈ A ó x ∈ B.
*}

lemma "(x ∈ A ∪ B) = (x ∈ A ∨ x ∈ B)"
by simp

text {*
Lema. [Analogía entre subconjunto e implicación]
A ⊆ B syss para todo x, si x ∈ A entonces x ∈ B.
*}

lemma "(A ⊆ B) = (∀ x. x ∈ A ⟶ x ∈ B)"
by auto

text {*
Lema. [Analogía entre complementario y negación]
x pertenece al complementario de A syss x no pertenece a A.
*}

lemma "(x ∈ -A) = (x ∉ A)"
by simp

subsection {* Notación de conjuntos finitos *}

text {*
Nota. La teoría de conjuntos finitos es HOL/Finite_Set.thy.

Nota. Los conjuntos finitos se definen por inducción a partir de las
siguientes reglas inductivas:
· El conjunto vacío es un conjunto finito.
· emptyI: "finite {}"
· Si se le añade un elemento a un conjunto finito se obtiene otro
conjunto finito.
· insertI: "finite A ⟹ finite (insert a A)"

A continuación se muestran ejemplos de conjuntos finitos.
*}

lemma
"insert 2 {} = {2} ∧
insert 3 {2} = {2,3} ∧
insert 2 {2,3} = {2,3} ∧
{2,3} = {3,2,3,2,2}"
by auto

text {*
Nota. Los conjuntos finitos se representan con la notación conjuntista
habitual: los elementos entre llaves y separados por comas.
*}

text {*
Ejemplo: {a,b} ∪ {c,d} = {a,b,c,d}
*}

lemma "{a,b} ∪ {c,d} = {a,b,c,d}"
by auto

text {*
Ejemplo de conjetura falsa y su refutación.
*}

lemma "{a,b} ∩ {b,c} = {b}"
oops

(* Auto Quickcheck found a counterexample:
a = a⇩1
b = a⇩2
c = a⇩1
Evaluated terms:
{a, b} ∩ {b, c} = {a⇩2, a⇩1}
{b} = {a⇩2}
*)

text {*
Ejemplo con la conjetura corregida.
*}

lemma "{a,b} ∩ {b,c} = (if a = c then {a,b} else {b})"
by auto

text {*
Sumas de conjuntos finitos:
· ∑A es la suma de los elementos del conjunto finito A. Por ejemplo,
value "∑{1,2,3}::int" -- "= 6"
· (setsum f A) es la suma de la aplicación de f a los elementos del
conjunto finito A, Por ejemplo,
value "setsum (λx. x*x) {1,2,3}::int" -- "= 14"
*}

text {*
Ejemplos de definiciones recursivas sobre conjuntos finitos:
Sea A un conjunto finito de números naturales.
· sumaConj A es la suma de los elementos A.
· sumaCuadradosConj A es la suma de los cuadrados de los elementos A.
*}

definition sumaConj :: "nat set ⇒ nat" where
"sumaConj S ≡ ∑S"

value "sumaConj {2,5,3}" ― ‹= 10›
value "∑{2::nat,5,3}" ― ‹= 10›

definition sumaCuadradosConj :: "nat set ⇒ nat" where
"sumaCuadradosConj S ≡ ∑x∈S. x*x"

value "sumaCuadradosConj {2,5,3}" ― ‹= 38›

text {*
Nota. Para simplificar lo que sigue, declaramos las anteriores
definiciones como reglas de simplificación.
*}

declare sumaConj_def [simp]
declare sumaCuadradosConj_def [simp]

text {*
Ejemplos de evaluación de las anteriores definiciones recursivas.
*}

lemma
"sumaConj {1,2,3,4} = 10 ∧
sumaCuadradosConj {1,2,3,4} = 30"
by simp

text {*
Inducción sobre conjuntos finitos: Para demostrar que todos los
conjuntos finitos tienen una propiedad P basta probar que
· El conjunto vacío tiene la propiedad P.
· Si a un conjunto finito que tiene la propiedad P se le añade un
nuevo elemento, el conjunto obtenido sigue teniendo la propiedad P.
En forma de regla
· finite_induct: ⟦finite F;
P {};
⋀x F. ⟦finite F; x ∉ F; P F⟧ ⟹ P ({x} ∪ F)⟧
⟹ P F
*}

text {*
Ejemplo de inducción sobre conjuntos finitos: Sea S un conjunto finito
de números naturales. Entonces todos los elementos de S son menores o
iguales que la suma de los elementos de S.
*}

― ‹La demostración aplicativa es›
lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
apply (induct rule: finite_induct)
(* 1. ∀x∈{}. x ≤ sumaConj {}
2. ⋀x F. ⟦finite F; x ∉ F; ∀x∈F. x ≤ sumaConj F⟧
⟹ ∀xa∈insert x F. xa ≤ sumaConj (insert x F) *)
apply simp
(* 1. ⋀x F. ⟦finite F; x ∉ F; ∀x∈F. x ≤ sumaConj F⟧
⟹ ∀xa∈insert x F. xa ≤ sumaConj (insert x F) *)
apply auto
(* *)
done

― ‹La demostración automática es›
lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
by (induct rule: finite_induct) auto

― ‹La demostración declarativa es›
lemma sumaConj_acota:
"finite S ⟹ ∀x∈S. x ≤ sumaConj S"
proof (induct rule: finite_induct)
show "∀x ∈ {}. x ≤ sumaConj {}" by simp
next
fix x and F
assume fF: "finite F"
and xF: "x ∉ F"
and HI: "∀ x∈F. x ≤ sumaConj F"
show "∀y ∈ insert x F. y ≤ sumaConj (insert x F)"
proof
fix y
assume "y ∈ insert x F"
show "y ≤ sumaConj (insert x F)"
proof (cases "y = x")
assume "y = x"
then have "y ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" by (simp add: fF xF)
finally show ?thesis .
next
assume "y ≠ x"
then have "y ∈ F" using `y ∈ insert x F` by simp
then have "y ≤ sumaConj F" using HI by blast
also have "… ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
qed
qed
qed

subsection {* Definiciones por comprensión *}

text {*
El conjunto de los elementos que cumple la propiedad P se representa
por {x. P}.

Reglas de comprensión (relación entre colección y pertenencia):
· mem_Collect_eq: (a ∈ {x. P x}) = P a
· Collect_mem_eq: {x. x ∈ A} = A
*}

text {*
Ejemplo de comprensión: {x. P x ∨ x ∈ A} = {x. P x} ∪ A
*}

lemma "{x. P x ∨ x ∈ A} = {x. P x} ∪ A"
by auto

text {*
Ejemplo de comprensión: {x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}
*}

lemma "{x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}"
by auto

text {*
Ejemplo con la sintaxis general de comprensión.
{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}
*}

lemma
"{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}"
by auto

text {*
En HOL, la notación conjuntista es azúcar sintáctica:
· x ∈ A es equivalente a A(x).
· {x. P} es equivalente a λx. P.
*}

text {*
Ejemplo de definición por comprensión: El conjunto de los pares es el
de los números n para los que existe un m tal que n = 2*m.
*}

definition Pares :: "nat set" where
"Pares ≡ {n. ∃m. n = 2*m }"

text {*
Ejemplo. Los números 2 y 34 son pares.
*}

lemma
"2 ∈ Pares ∧
34 ∈ Pares"
by (simp add: Pares_def)

text {*
Definición. El conjunto de los impares es el de los números n para los
que existe un m tal que n = 2*m + 1.
*}

definition Impares :: "nat set" where
"Impares ≡ {n. ∃m. n = 2*m + 1}"

text {*
Ejemplo con las reglas de intersección y comprensión: El conjunto de
los pares es disjunto con el de los impares.
*}

― ‹Demostración aplicativa›
lemma "x ∉ (Pares ∩ Impares)"
apply auto
(* ⟦x ∈ Pares; x ∈ Impares⟧ ⟹ False *)
apply (simp add: Pares_def Impares_def)
(* ⟦∃m. x = 2 * m; ∃m. x = Suc (2 * m)⟧ ⟹ False *)
apply presburger
(* *)
done

― ‹Demostración aplicativa sin auto ni presburger›
lemma "x ∉ (Pares ∩ Impares)"
apply (rule notI)
(* x ∈ Pares ∩ Impares ⟹ False *)
apply (erule IntE)
(* ⟦x ∈ Pares; x ∈ Impares⟧ ⟹ False *)
apply (simp add: Pares_def Impares_def)
(* ⟦∃m. x = 2 * m; ∃m. x = Suc (2 * m)⟧ ⟹ False *)
apply (erule exE)+
(* ⋀m ma. ⟦x = 2 * m; x = Suc (2 * ma)⟧ ⟹ False *)
apply (simp add: Suc_double_not_eq_double)
(* *)
done

― ‹Demostración automática›
lemma "x ∉ (Pares ∩ Impares)"
by (auto simp add: Pares_def Impares_def, presburger)

― ‹Demostración declarativa›
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
then have "x ∈ Pares" ..
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" ..
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by presburger
qed

― ‹2ª demostración declarativa sin implícitos ni presburger›
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
then have "x ∈ Pares" by (rule IntD1)
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" by (rule IntD2)
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by (simp add: Suc_double_not_eq_double)
qed

subsection {* Cuantificadores acotados *}

text {*
Reglas de cuantificador universal acotado ("bounded"):
· ballI: (⋀x. x ∈ A ⟹ P x) ⟹ ∀x∈A. P x
· bspec: ⟦∀x∈A. P x; x ∈ A⟧ ⟹ P x

Reglas de cuantificador existencial acotado ("bounded"):
· bexI: ⟦P x; x ∈ A⟧ ⟹ ∃x∈A. P x
· bexE: ⟦∃x∈A. P x; ⋀x. ⟦x ∈ A; P x⟧ ⟹ Q⟧ ⟹ Q

Reglas de la unión indexada:
· UN_iff: (b ∈ (⋃x∈A. B x)) = (∃x∈A. b ∈ B x)
· UN_I: ⟦a ∈ A; b ∈ B a⟧ ⟹ b ∈ (⋃x∈A. B x)
· UN_E: ⟦b ∈ (⋃x∈A. B x); ⋀x. ⟦x ∈ A; b ∈ B x⟧ ⟹ R⟧ ⟹ R

Reglas de la unión de una familia:
· Union_def: ⋃S = (⋃x∈S. x)
· Union_iff: (A ∈ ⋃C) = (∃X∈C. A ∈ X)

Reglas de la intersección indexada:
· INT_iff: (b ∈ (⋂x∈A. B x)) = (∀x∈A. b ∈ B x)
· INT_I: (⋀x. x ∈ A ⟹ b ∈ B x) ⟹ b ∈ (⋂x∈A. B x)
· INT_E: ⟦b ∈ (⋂x∈A. B x); b ∈ B a ⟹ R; a ∉ A ⟹ R⟧ ⟹ R

Reglas de la intersección de una familia:
· Inter_def: ⋂S = (⋂x∈S. x)
· Inter_iff: (A ∈ ⋂C) = (∀X∈C. A ∈ X)

Abreviaturas:
· "Collect P" es lo mismo que "{x. P}".
· "All P" es lo mismo que "∀x. P x".
· "Ex P" es lo mismo que "∃x. P x".
· "Ball A P" es lo mismo que "∀x∈A. P x".
· "Bex A P" es lo mismo que "∃x∈A. P x".
*}

subsection {* Conjuntos finitos y cardinalidad *}

text {*
El número de elementos de un conjunto finito A es el cardinal de A y
se representa por "card A".
*}

text {*
Ejemplos de cardinales de conjuntos finitos.
*}

lemma
"card {} = 0 ∧
card {4} = 1 ∧
card {4,1} = 2 ∧
x ≠ y ⟹ card {x,y} = 2"
by simp

text {*
Propiedades de cardinales:
· Cardinal de la unión de conjuntos finitos:
card_Un_Int: ⟦finite A; finite B⟧
⟹ card A + card B = card (A ∪ B) + card (A ∩ B)"
· Cardinal del conjunto potencia:
card_Pow: finite A ⟹ card (Pow A) = 2 ^ card A
*}

section {* Funciones *}

text {*
La teoría de funciones es HOL/Fun.thy.
*}

subsection {* Nociones básicas de funciones *}

text {*
Principio de extensionalidad para funciones:
· ext: (⋀x. f x = g x) ⟹ f = g

Actualización de funciones
· fun_upd_apply: (f(x := y)) z = (if z = x then y else f z)
· fun_upd_upd: f(x := y, x := z) = f(x := z)

Función identidad
· id_def: id ≡ λx. x

Composición de funciones:
· o_def: f ∘ g = (λx. f (g x))

Asociatividad de la composición:
· o_assoc: f ∘ (g ∘ h) = (f ∘ g) ∘ h
*}

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

text {*
Función inyectiva sobre A:
· inj_on_def: inj_on f A ≡ ∀x∈A. ∀y∈A. f x = f y ⟶ x = y

Nota. "inj f" es una abreviatura de "inj_on f UNIV".

Función suprayectiva:
· surj_def: surj f ≡ ∀y. ∃x. y = f x

Función biyectiva:
· bij_def: bij f ≡ inj f ∧ surj f

Propiedades de las funciones inversas:
· inv_f_f: inj f ⟹ inv f (f x) = x
· surj_f_inv_f: surj f ⟹ f (inv f y) = y
· inv_inv_eq: bij f ⟹ inv (inv f) = f

Igualdad de funciones (por extensionalidad):
· fun_eq_iff: (f = g) = (∀x. f x = g x)
*}

text {*
Ejemplo de lema de demostración de propiedades de funciones: Una
función inyectiva puede cancelarse en el lado izquierdo de la
composición de funciones.
*}

― ‹Demostración applicativa›
lemma
"inj f ⟹ (f ∘ g = f ∘ h) = (g = h)"
apply (simp add: inj_on_def fun_eq_iff)
(* ∀x y. f x = f y ⟶ x = y ⟹
(∀x. f (g x) = f (h x)) = (∀x. g x = h x)*)
apply auto
(* *)
done

― ‹Demostración applicativa sin auto›
lemma
"inj f ⟹ (f ∘ g = f ∘ h) = (g = h)"
apply (unfold inj_on_def)
(* ∀x∈UNIV. ∀y∈UNIV. f x = f y ⟶ x = y ⟹
(f ∘ g = f ∘ h) = (g = h)*)
apply (unfold fun_eq_iff)
(* ∀x∈UNIV. ∀y∈UNIV. f x = f y ⟶ x = y ⟹
(∀x. (f ∘ g) x = (f ∘ h) x) = (∀x. g x = h x))*)
apply (unfold o_apply)
(* ∀x∈UNIV. ∀y∈UNIV. f x = f y ⟶ x = y ⟹
(∀x. f (g x) = f (h x)) = (∀x. g x = h x) *)
apply (rule iffI)
(* 1. ⟦∀x∈UNIV. ∀y∈UNIV. f x = f y ⟶ x = y;
∀x. f (g x) = f (h x)⟧
⟹ ∀x. g x = h x
2. ⟦∀x∈UNIV. ∀y∈UNIV. f x = f y ⟶ x = y;
∀x. g x = h x⟧
⟹ ∀x. f (g x) = f (h x)*)
apply simp+
(* *)
done

― ‹Demostración automática›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
using assms
by (auto simp add: inj_on_def fun_eq_iff)

― ‹Demostración declarativa›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
show "g = h"
proof
fix x
have "(f ∘ g)(x) = (f ∘ h)(x)" using `f ∘ g = f ∘ h` by simp
then have "f(g(x)) = f(h(x))" by simp
then show "g(x) = h(x)" using `inj f` by (simp add:inj_on_def)
qed
next
assume "g = h"
show "f ∘ g = f ∘ h"
proof
fix x
have "(f ∘ g) x = f(g(x))" by simp
also have "… = f(h(x))" using `g = h` by simp
also have "… = (f ∘ h) x" by simp
finally show "(f ∘ g) x = (f ∘ h) x" by simp
qed
qed

― ‹2ª demostración declarativa›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
then show "g = h" using `inj f` by (simp add: inj_on_def fun_eq_iff)
next
assume "g = h"
then show "f ∘ g = f ∘ h" by simp
qed

subsubsection {* Función imagen *}

text {*
Imagen de un conjunto mediante una función:
· image_def: f ` A = {y. (∃x∈A. y = f x)}

Propiedades de la imagen:
· image_compose: (f ∘ g)`r = f`g`r
· image_Un: f`(A ∪ B) = f`A ∪ f`B
· image_Int: inj f ⟹ f`(A ∩ B) = f`A ∩ f`B"
*}

text {*
Ejemplo de demostración de propiedades de la imagen:
f`A ∪ g`A = (⋃x∈A. {f x, g x})
*}

lemma "f`A ∪ g`A = (⋃x∈A. {f x, g x})"
by auto

text {*
Ejemplo de demostración de propiedades de la imagen:
f`{(x,y). P x y} = {f(x,y) | x y. P x y}
*}

lemma "f`{(x,y). P x y} = {f(x,y) | x y. P x y}"
by auto

text {*
El rango de una función ("range f") es la imagen del universo
("f`UNIV").

Imagen inversa de un conjunto:
· vimage_def: f -` B ≡ {x. f x ∈ B}

Propiedad de la imagen inversa de un conjunto:
· vimage_Compl: f -` (-A) = -(f -` A)
*}

section {* Relaciones *}

subsection {* Relaciones básicas *}

text {*
La teoría de relaciones es HOL/Relation.thy.

Las relaciones son conjuntos de pares.

Relación identidad:
· Id_def: Id ≡ {p. ∃x. p = (x,x)}

Composición de relaciones:
· rel_comp_def: r O s ≡ {(x,z). ∃y. (x, y) ∈ r ∧ (y, z) ∈ s}

Propiedades:
· R_O_Id: R O Id = R
· rel_comp_mono: ⟦r' ⊆ r; s' ⊆ s⟧ ⟹ (r' O s') ⊆ (r O s)

Imagen inversa de una relación:
· converse_iff: ((a,b) ∈ r^-1) = ((b,a) ∈ r)

Propiedad de la imagen inversa de una relación:
· converse_rel_comp: (r O s)^-1 = s^-1 O r^-1

Imagen de un conjunto mediante una relación:
· Image_iff: (b ∈ r``A) = (∃x:A. (x, b) ∈ r)

Dominio de una relación:
· Domain_iff: (a ∈ Domain r) = (∃y. (a, y) ∈ r)

Rango de una relación:
· Range_iff: (a ∈ Range r) = (∃y. (y,a) ∈ r)
*}

end
</source>

Temas

2019-05-13T08:43:52Z

Jalonso:

En esta página se encuentra el material (transparencias y teorías) del curso ''Lógica matemática y fundamentos''.

* Tema 1: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-1.pdf Sintaxis y semántica de la lógica proposicional].
* Tema 2: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-2.pdf Deducción natural proposicional].
* Tema 2a: [[Deducción natural proposicional con Isabelle/HOL]].
* Tema 2b: [[Deducción natural proposicional con Isabelle/HOL basada en tácticas]].
* Tema 3: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-3.pdf Sintaxis y semántica de la lógica de primer orden].
* Tema 4: [https://www.cs.us.es/~jalonso/cursos/lmf-18/temas/tema-4.pdf Deducción natural en lógica de primer orden].
* Tema 4a: [https://www.glc.us.es/~jalonso/LMF2019/index.php/Tema_4a Deducción natural en lógica de primer orden con Isabelle/HOL].
* Tema 4b: [[Deducción natural en lógica de primer orden con Isabelle/HOL basada en tácticas]].
* Tema 5: [[Programación funcional en Isabelle/HOL]].
* Tema 6: [https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8.pdf Razonamiento sobre programas].
* Tema 6a: [[Razonamiento sobre programas en Isabelle/HOL]].
* Tema 7: [[Razonamiento por casos y por inducci¢n]].
* Tema 8: [[Razonamiento sobre árboles y bosques]].
* Tema 9: [[Definiciones inductivas]].
* Tema 10: [[Conjuntos, funciones y relaciones]].
* Tema 11: [[Desarrollo de teorías formalizadas con Isabelle/HOL]].

Desarrollo de teorías formalizadas con Isabelle/HOL

2019-05-13T08:43:26Z

Jalonso:

Desarrollo de teor¡as formalizadas con Isabelle/HOL

2019-05-13T08:43:26Z

Jalonso:

#REDIRECCIÓN [[Desarrollo de teorías formalizadas con Isabelle/HOL]]

Desarrollo de teorías formalizadas con Isabelle/HOL

2019-05-12T17:19:16Z

Jalonso:

Conjuntos, funciones y relaciones

2019-05-09T06:48:59Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 10: Conjuntos, funciones y relaciones *}

theory T10_Conjuntos_funciones_y_relaciones
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

text {*
Nota. La teoría elemental de conjuntos es HOL/Set.thy.

Nota. En un conjunto todos los elemento son del mismo tipo (por
ejemplo, del tipo τ) y el conjunto tiene tipo (en el ejemplo, "τ set").

Reglas de la intersección:
· IntI: ⟦c ∈ A; c ∈ B⟧ ⟹ c ∈ A ∩ B
· IntD1: c ∈ A ∩ B ⟹ c ∈ A
· IntD2: c ∈ A ∩ B ⟹ c ∈ B

Nota. Propiedades del complementario:
· Compl_iff: (c ∈ - A) = (c ∉ A)
· Compl_Un: - (A ∪ B) = - A ∩ - B

Nota. El conjunto vacío se representa por {} y el universal por UNIV.

Nota. Propiedades de la diferencia y del complementario:
· Diff_disjoint: A ∩ (B - A) = {}
· Compl_partition: A ∪ - A = UNIV

Nota. Reglas de la relación de subconjunto:
· subsetI: (⋀x. x ∈ A ⟹ x ∈ B) ⟹ A ⊆ B
· subsetD: ⟦A ⊆ B; c ∈ A⟧ ⟹ c ∈ B
*}

text {*
Ejemplo: A ∪ B ⊆ C syss A ⊆ C ∧ B ⊆ C.
*}

lemma "(A ∪ B ⊆ C) = (A ⊆ C ∧ B ⊆ C)"
by simp

text {*
Ejemplo: A ⊆ -B syss B ⊆ -A.
*}

lemma "(A ⊆ -B) = (B ⊆ -A)"
by auto

text {*
Principio de extensionalidad de conjuntos:
· set_eqI: (⋀x. (x ∈ A) = (x ∈ B)) ⟹ A = B

Reglas de la igualdad de conjuntos:
· equalityI: ⟦A ⊆ B; B ⊆ A⟧ ⟹ A = B
· equalityD1: A = B ⟹ A ⊆ B
· equalityD2: A = B ⟹ B ⊆ A
· equalityE: ⟦A = B; ⟦A ⊆ B; B ⊆ A⟧ ⟹ P⟧ ⟹ P
*}

text {*
Lema. [Analogía entre intersección y conjunción]
"x ∈ A ∩ B" syss "x ∈ A" y "x ∈ B".
*}

lemma "(x ∈ A ∩ B) = (x ∈ A ∧ x ∈ B)"
by simp

text {*
Lema. [Analogía entre unión y disyunción]
x ∈ A ∪ B syss x ∈ A ó x ∈ B.
*}

lemma "(x ∈ A ∪ B) = (x ∈ A ∨ x ∈ B)"
by simp

text {*
Lema. [Analogía entre subconjunto e implicación]
A ⊆ B syss para todo x, si x ∈ A entonces x ∈ B.
*}

lemma "(A ⊆ B) = (∀ x. x ∈ A ⟶ x ∈ B)"
by auto

text {*
Lema. [Analogía entre complementario y negación]
x pertenece al complementario de A syss x no pertenece a A.
*}

lemma "(x ∈ -A) = (x ∉ A)"
by simp

subsection {* Notación de conjuntos finitos *}

text {*
Nota. La teoría de conjuntos finitos es HOL/Finite_Set.thy.

Nota. Los conjuntos finitos se definen por inducción a partir de las
siguientes reglas inductivas:
· El conjunto vacío es un conjunto finito.
· emptyI: "finite {}"
· Si se le añade un elemento a un conjunto finito se obtiene otro
conjunto finito.
· insertI: "finite A ⟹ finite (insert a A)"

A continuación se muestran ejemplos de conjuntos finitos.
*}

lemma
"insert 2 {} = {2} ∧
insert 3 {2} = {2,3} ∧
insert 2 {2,3} = {2,3} ∧
{2,3} = {3,2,3,2,2}"
by auto

text {*
Nota. Los conjuntos finitos se representan con la notación conjuntista
habitual: los elementos entre llaves y separados por comas.
*}

text {*
Ejemplo: {a,b} ∪ {c,d} = {a,b,c,d}
*}

lemma "{a,b} ∪ {c,d} = {a,b,c,d}"
by auto

text {*
Ejemplo de conjetura falsa y su refutación.
*}

lemma "{a,b} ∩ {b,c} = {b}"
oops

(* Auto Quickcheck found a counterexample:
a = a⇩1
b = a⇩2
c = a⇩1
Evaluated terms:
{a, b} ∩ {b, c} = {a⇩2, a⇩1}
{b} = {a⇩2}
*)

text {*
Ejemplo con la conjetura corregida.
*}

lemma "{a,b} ∩ {b,c} = (if a = c then {a,b} else {b})"
by auto

text {*
Sumas de conjuntos finitos:
· ∑A es la suma de los elementos del conjunto finito A. Por ejemplo,
value "∑{1,2,3}::int" -- "= 6"
· (setsum f A) es la suma de la aplicación de f a los elementos del
conjunto finito A, Por ejemplo,
value "setsum (λx. x*x) {1,2,3}::int" -- "= 14"
*}

text {*
Ejemplos de definiciones recursivas sobre conjuntos finitos:
Sea A un conjunto finito de números naturales.
· sumaConj A es la suma de los elementos A.
· sumaCuadradosConj A es la suma de los cuadrados de los elementos A.
*}

definition sumaConj :: "nat set ⇒ nat" where
"sumaConj S ≡ ∑S"

value "sumaConj {2,5,3}" ― ‹= 10›
value "∑{2::nat,5,3}" ― ‹= 10›

definition sumaCuadradosConj :: "nat set ⇒ nat" where
"sumaCuadradosConj S ≡ ∑x∈S. x*x"

value "sumaCuadradosConj {2,5,3}" ― ‹= 38›

text {*
Nota. Para simplificar lo que sigue, declaramos las anteriores
definiciones como reglas de simplificación.
*}

declare sumaConj_def [simp]
declare sumaCuadradosConj_def [simp]

text {*
Ejemplos de evaluación de las anteriores definiciones recursivas.
*}

lemma
"sumaConj {1,2,3,4} = 10 ∧
sumaCuadradosConj {1,2,3,4} = 30"
by simp

text {*
Inducción sobre conjuntos finitos: Para demostrar que todos los
conjuntos finitos tienen una propiedad P basta probar que
· El conjunto vacío tiene la propiedad P.
· Si a un conjunto finito que tiene la propiedad P se le añade un
nuevo elemento, el conjunto obtenido sigue teniendo la propiedad P.
En forma de regla
· finite_induct: ⟦finite F;
P {};
⋀x F. ⟦finite F; x ∉ F; P F⟧ ⟹ P ({x} ∪ F)⟧
⟹ P F
*}

text {*
Ejemplo de inducción sobre conjuntos finitos: Sea S un conjunto finito
de números naturales. Entonces todos los elementos de S son menores o
iguales que la suma de los elementos de S.
*}

― ‹La demostración aplicativa es›
lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
apply (induct rule: finite_induct)
(* 1. ∀x∈{}. x ≤ sumaConj {}
2. ⋀x F. ⟦finite F; x ∉ F; ∀x∈F. x ≤ sumaConj F⟧
⟹ ∀xa∈insert x F. xa ≤ sumaConj (insert x F) *)
apply auto
(* *)
done

― ‹La demostración automática es›
lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
by (induct rule: finite_induct) auto

― ‹La demostración declarativa es›
lemma sumaConj_acota:
"finite S ⟹ ∀x∈S. x ≤ sumaConj S"
proof (induct rule: finite_induct)
show "∀x ∈ {}. x ≤ sumaConj {}" by simp
next
fix x and F
assume fF: "finite F"
and xF: "x ∉ F"
and HI: "∀ x∈F. x ≤ sumaConj F"
show "∀y ∈ insert x F. y ≤ sumaConj (insert x F)"
proof
fix y
assume "y ∈ insert x F"
show "y ≤ sumaConj (insert x F)"
proof (cases "y = x")
assume "y = x"
then have "y ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
next
assume "y ≠ x"
then have "y ∈ F" using `y ∈ insert x F` by simp
then have "y ≤ sumaConj F" using HI by blast
also have "… ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
qed
qed
qed

subsection {* Definiciones por comprensión *}

text {*
El conjunto de los elementos que cumple la propiedad P se representa
por {x. P}.

Reglas de comprensión (relación entre colección y pertenencia):
· mem_Collect_eq: (a ∈ {x. P x}) = P a
· Collect_mem_eq: {x. x ∈ A} = A
*}

text {*
Ejemplo de comprensión: {x. P x ∨ x ∈ A} = {x. P x} ∪ A
*}

lemma "{x. P x ∨ x ∈ A} = {x. P x} ∪ A"
by auto

text {*
Ejemplo de comprensión: {x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}
*}

lemma "{x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}"
by auto

text {*
Ejemplo con la sintaxis general de comprensión.
{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}
*}

lemma
"{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}"
by auto

text {*
En HOL, la notación conjuntista es azúcar sintáctica:
· x ∈ A es equivalente a A(x).
· {x. P} es equivalente a λx. P.
*}

text {*
Ejemplo de definición por comprensión: El conjunto de los pares es el
de los números n para los que existe un m tal que n = 2*m.
*}

definition Pares :: "nat set" where
"Pares ≡ {n. ∃m. n = 2*m }"

text {*
Ejemplo. Los números 2 y 34 son pares.
*}

lemma
"2 ∈ Pares ∧
34 ∈ Pares"
by (simp add: Pares_def)

text {*
Definición. El conjunto de los impares es el de los números n para los
que existe un m tal que n = 2*m + 1.
*}

definition Impares :: "nat set" where
"Impares ≡ {n. ∃m. n = 2*m + 1}"

text {*
Ejemplo con las reglas de intersección y comprensión: El conjunto de
los pares es disjunto con el de los impares.
*}

― ‹Demostración aplicativa›
lemma "x ∉ (Pares ∩ Impares)"
apply auto
(* ⟦x ∈ Pares; x ∈ Impares⟧ ⟹ False *)
apply (simp add: Pares_def Impares_def)
(* ⟦∃m. x = 2 * m; ∃m. x = Suc (2 * m)⟧ ⟹ False *)
apply arith
(* *)
done

― ‹Demostración automática›
lemma "x ∉ (Pares ∩ Impares)"
by (auto simp add: Pares_def Impares_def, arith)

― ‹Demostración declarativa›
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
then have "x ∈ Pares" by (rule IntD1)
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" by (rule IntD2)
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

― ‹2ª demostración declarativa›
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
then have "x ∈ Pares" ..
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" ..
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

subsection {* Cuantificadores acotados *}

text {*
Reglas de cuantificador universal acotado ("bounded"):
· ballI: (⋀x. x ∈ A ⟹ P x) ⟹ ∀x∈A. P x
· bspec: ⟦∀x∈A. P x; x ∈ A⟧ ⟹ P x

Reglas de cuantificador existencial acotado ("bounded"):
· bexI: ⟦P x; x ∈ A⟧ ⟹ ∃x∈A. P x
· bexE: ⟦∃x∈A. P x; ⋀x. ⟦x ∈ A; P x⟧ ⟹ Q⟧ ⟹ Q

Reglas de la unión indexada:
· UN_iff: (b ∈ (⋃x∈A. B x)) = (∃x∈A. b ∈ B x)
· UN_I: ⟦a ∈ A; b ∈ B a⟧ ⟹ b ∈ (⋃x∈A. B x)
· UN_E: ⟦b ∈ (⋃x∈A. B x); ⋀x. ⟦x ∈ A; b ∈ B x⟧ ⟹ R⟧ ⟹ R

Reglas de la unión de una familia:
· Union_def: ⋃S = (⋃x∈S. x)
· Union_iff: (A ∈ ⋃C) = (∃X∈C. A ∈ X)

Reglas de la intersección indexada:
· INT_iff: (b ∈ (⋂x∈A. B x)) = (∀x∈A. b ∈ B x)
· INT_I: (⋀x. x ∈ A ⟹ b ∈ B x) ⟹ b ∈ (⋂x∈A. B x)
· INT_E: ⟦b ∈ (⋂x∈A. B x); b ∈ B a ⟹ R; a ∉ A ⟹ R⟧ ⟹ R

Reglas de la intersección de una familia:
· Inter_def: ⋂S = (⋂x∈S. x)
· Inter_iff: (A ∈ ⋂C) = (∀X∈C. A ∈ X)

Abreviaturas:
· "Collect P" es lo mismo que "{x. P}".
· "All P" es lo mismo que "∀x. P x".
· "Ex P" es lo mismo que "∃x. P x".
· "Ball A P" es lo mismo que "∀x∈A. P x".
· "Bex A P" es lo mismo que "∃x∈A. P x".
*}

subsection {* Conjuntos finitos y cardinalidad *}

text {*
El número de elementos de un conjunto finito A es el cardinal de A y
se representa por "card A".
*}

text {*
Ejemplos de cardinales de conjuntos finitos.
*}

lemma
"card {} = 0 ∧
card {4} = 1 ∧
card {4,1} = 2 ∧
x ≠ y ⟹ card {x,y} = 2"
by simp

text {*
Propiedades de cardinales:
· Cardinal de la unión de conjuntos finitos:
card_Un_Int: ⟦finite A; finite B⟧
⟹ card A + card B = card (A ∪ B) + card (A ∩ B)"
· Cardinal del conjunto potencia:
card_Pow: finite A ⟹ card (Pow A) = 2 ^ card A
*}

section {* Funciones *}

text {*
La teoría de funciones es HOL/Fun.thy.
*}

subsection {* Nociones básicas de funciones *}

text {*
Principio de extensionalidad para funciones:
· ext: (⋀x. f x = g x) ⟹ f = g

Actualización de funciones
· fun_upd_apply: (f(x := y)) z = (if z = x then y else f z)
· fun_upd_upd: f(x := y, x := z) = f(x := z)

Función identidad
· id_def: id ≡ λx. x

Composición de funciones:
· o_def: f ∘ g = (λx. f (g x))

Asociatividad de la composición:
· o_assoc: f ∘ (g ∘ h) = (f ∘ g) ∘ h
*}

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

text {*
Función inyectiva sobre A:
· inj_on_def: inj_on f A ≡ ∀x∈A. ∀y∈A. f x = f y ⟶ x = y

Nota. "inj f" es una abreviatura de "inj_on f UNIV".

Función suprayectiva:
· surj_def: surj f ≡ ∀y. ∃x. y = f x

Función biyectiva:
· bij_def: bij f ≡ inj f ∧ surj f

Propiedades de las funciones inversas:
· inv_f_f: inj f ⟹ inv f (f x) = x
· surj_f_inv_f: surj f ⟹ f (inv f y) = y
· inv_inv_eq: bij f ⟹ inv (inv f) = f

Igualdad de funciones (por extensionalidad):
· fun_eq_iff: (f = g) = (∀x. f x = g x)
*}

text {*
Ejemplo de lema de demostración de propiedades de funciones: Una
función inyectiva puede cancelarse en el lado izquierdo de la
composición de funciones.
*}

― ‹Demostración applicativa›
lemma
"inj f ⟹ (f ∘ g = f ∘ h) = (g = h)"
apply (simp add: inj_on_def fun_eq_iff)
apply auto
done

― ‹Demostración automática›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
using assms
by (auto simp add: inj_on_def fun_eq_iff)

― ‹Demostración declarativa›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
show "g = h"
proof
fix x
have "(f ∘ g)(x) = (f ∘ h)(x)" using `f ∘ g = f ∘ h` by simp
then have "f(g(x)) = f(h(x))" by simp
then show "g(x) = h(x)" using `inj f` by (simp add:inj_on_def)
qed
next
assume "g = h"
show "f ∘ g = f ∘ h"
proof
fix x
have "(f ∘ g) x = f(g(x))" by simp
also have "… = f(h(x))" using `g = h` by simp
also have "… = (f ∘ h) x" by simp
finally show "(f ∘ g) x = (f ∘ h) x" by simp
qed
qed

― ‹2ª demostración declarativa›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
then show "g = h" using `inj f` by (simp add: inj_on_def fun_eq_iff)
next
assume "g = h"
then show "f ∘ g = f ∘ h" by auto
qed

subsubsection {* Función imagen *}

text {*
Imagen de un conjunto mediante una función:
· image_def: f ` A = {y. (∃x∈A. y = f x)}

Propiedades de la imagen:
· image_compose: (f ∘ g)`r = f`g`r
· image_Un: f`(A ∪ B) = f`A ∪ f`B
· image_Int: inj f ⟹ f`(A ∩ B) = f`A ∩ f`B"
*}

text {*
Ejemplo de demostración de propiedades de la imagen:
f`A ∪ g`A = (⋃x∈A. {f x, g x})
*}

lemma "f`A ∪ g`A = (⋃x∈A. {f x, g x})"
by auto

text {*
Ejemplo de demostración de propiedades de la imagen:
f`{(x,y). P x y} = {f(x,y) | x y. P x y}
*}

lemma "f`{(x,y). P x y} = {f(x,y) | x y. P x y}"
by auto

text {*
El rango de una función ("range f") es la imagen del universo
("f`UNIV").

Imagen inversa de un conjunto:
· vimage_def: f -` B ≡ {x. f x ∈ B}

Propiedad de la imagen inversa de un conjunto:
· vimage_Compl: f -` (-A) = -(f -` A)
*}

section {* Relaciones *}

subsection {* Relaciones básicas *}

text {*
La teoría de relaciones es HOL/Relation.thy.

Las relaciones son conjuntos de pares.

Relación identidad:
· Id_def: Id ≡ {p. ∃x. p = (x,x)}

Composición de relaciones:
· rel_comp_def: r O s ≡ {(x,z). ∃y. (x, y) ∈ r ∧ (y, z) ∈ s}

Propiedades:
· R_O_Id: R O Id = R
· rel_comp_mono: ⟦r' ⊆ r; s' ⊆ s⟧ ⟹ (r' O s') ⊆ (r O s)

Imagen inversa de una relación:
· converse_iff: ((a,b) ∈ r^-1) = ((b,a) ∈ r)

Propiedad de la imagen inversa de una relación:
· converse_rel_comp: (r O s)^-1 = s^-1 O r^-1

Imagen de un conjunto mediante una relación:
· Image_iff: (b ∈ r``A) = (∃x:A. (x, b) ∈ r)

Dominio de una relación:
· Domain_iff: (a ∈ Domain r) = (∃y. (a, y) ∈ r)

Rango de una relación:
· Range_iff: (a ∈ Range r) = (∃y. (y,a) ∈ r)
*}

end
</source>

Definiciones inductivas

2019-05-04T07:49:31Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 9: Definiciones inductivas *}

theory T9_Definiciones_inductivas
imports Main
begin

section {* El conjunto de los números pares *}

text {*
· El conjunto de los números pares se define inductivamente como el
menor conjunto que contiene al 0 y es cerrado por la operación (+2).

· El conjunto de los números pares también puede definirse como los
naturales divisible por 2.

· Veremos cómo se escriben las dos definiciones en Isabelle/HOL y cómo
se demuestra su equivalencia.
*}

subsection {* Definición inductiva del conjunto de los pares *}

inductive_set par :: "nat set" where
cero [intro!]: "0 ∈ par"
| paso [intro!]: "n ∈ par ⟹ (Suc (Suc n)) ∈ par"

text {*
· Una definición inductiva está formada con reglas de introducción.

· La definición inductiva genera varios teoremas:
· par.cero: 0 ∈ par
· par.paso: n ∈ par ⟹ Suc (Suc n) ∈ par
· par.simps: (a ∈ par) = (a = 0 ∨ (∃n. a = Suc (Suc n) ∧ n ∈ par))
*}

subsection {* Uso de las reglas de introducción *}

text {*
Lema: Los números de la forma 2*k son pares.
*}

― ‹La demostración aplicativa es›
lemma dobles_son_pares [intro!]:
"2*k ∈ par"
apply (induct k)
(* 1. 2 * 0 ∈ par
2. ⋀k. 2 * k ∈ par ⟹ 2 * Suc k ∈ par *)
apply auto
(* *)
done

― ‹La demostración automática es›
lemma dobles_son_pares_2:
"2*k ∈ par"
by (induct k) auto

― ‹La demostración estructurada es›
lemma dobles_son_pares_3:
"2*k ∈ par"
proof (induct k)
show "2 * 0 ∈ par" by auto
next
show "⋀k. 2 * k ∈ par ⟹ 2 * Suc k ∈ par" by auto
qed

text {*
· Nota: Nuestro objetivo es demostrar la equivalencia de la definición
anterior y la definición mediante divisibilidad (even).

· Lema: Si n es divisible por 2, entonces es par.
*}

lemma even_imp_par: "even n ⟹ n ∈ par"
by auto

subsection {* Regla de inducción *}

text {*
Entre las reglas generadas por la definión de par está la de
inducción:
· par.induct: ⟦ x ∈ par;
P 0;
⋀n. ⟦n ∈ par; P n⟧ ⟹ P (Suc (Suc n))⟧
⟹ P x
*}

text {*
Lema: Los números pares son divisibles por 2.
*}

― ‹Demostración aplicativa›
lemma par_imp_even:
"n ∈ par ⟹ even n"
apply (induction rule: par.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (simp only: dvd_def)
(* 1. ∃k. 0 = 2 * k
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (rule_tac x=0 in exI)
(* 1. 0 = 2 * 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply simp
(* ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply (simp only: dvd_def)
(* ⋀n. ⟦n ∈ par; ∃k. n = 2 * k⟧ ⟹ ∃k. Suc (Suc n) = 2 * k *)
apply (erule exE)
(* ⋀n k. ⟦n ∈ par; n = 2 * k⟧ ⟹ ∃k. Suc (Suc n) = 2 * k*)
apply (rule_tac x="k+1" in exI)
(* ⋀n k. ⟦n ∈ par; n = 2 * k⟧ ⟹ Suc (Suc n) = 2 * (k + 1) *)
apply simp
(* *)
done

― ‹2ª demostración aplicativa›
lemma par_imp_even_2:
"n ∈ par ⟹ even n"
apply (induction rule: par.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ par; even n⟧ ⟹ even (Suc (Suc n)) *)
apply simp_all
(* *)
done

― ‹Demostración automática›
lemma par_imp_even_3:
"n ∈ par ⟹ even n"
by (induction rule:par.induct) simp_all

― ‹Demostración declarativa›
lemma par_imp_even_4:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "even 0" by simp
next
fix n::nat
assume H1: "n ∈ par" and
H2: "even n"
have "∃k. n = 2*k" using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k" ..
then have "Suc (Suc n) = 2*(k+1)" by simp
then have "∃k. Suc (Suc n) = 2*k" ..
then show "even (Suc (Suc n))" by (simp add: dvd_def)
qed

― ‹2ª demostración declarativa›
lemma par_imp_even_5:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "even 0" by simp
next
fix n::nat
assume H1: "n ∈ par" and
H2: "even n"
then show "even (Suc (Suc n))" by simp
qed

text {*
Lema: Un número n es par syss es divisible por 2.
*}

theorem par_iff_even: "(n ∈ par) = (even n)"
by (blast intro: even_imp_par par_imp_even)

subsection{* Generalización y regla de inducción *}

text {*
· Antes de aplicar inducción se debe de generalizar la fórmula a
probar.

· Vamos a ilustrar el principio anterior en el caso de los conjuntos
inductivamente definidos, con el siguiente ejemplo: si n+2 es par,
entonces n también lo es.

· El siguiente intento falla:
*}

lemma "Suc (Suc n) ∈ par ⟹ n ∈ par"
apply (erule par.induct)
(* 1. n ∈ par
2. ⋀na. ⟦na ∈ par; n ∈ par⟧ ⟹ n ∈ par *)
oops

text {*
En el intento anterior, los subobjetivos generados son
1. n ∈ par
2. ⋀na. ⟦na ∈ par; n ∈ par⟧ ⟹ n ∈ par
que no se pueden demostrar.

Se ha perdido la información sobre Suc (Suc n).
*}

text {*
Reformulación del lema: Si n es par, entonces n-2 también lo es.
*}

― ‹La demostración aplicativa es›
lemma par_imp_par_menos:
"n ∈ par ⟹ n - 2 ∈ par"
apply (induction rule: par.induct)
(* 1. 0 - 2 ∈ par
2. ⋀n. ⟦n ∈ par; n - 2 ∈ par⟧ ⟹ Suc (Suc n) - 2 ∈ par *)
apply auto
(* *)
done

― ‹La demostración automática es›
lemma par_imp_par_menos_2:
"n ∈ par ⟹ n - 2 ∈ par"
by (induction rule: par.induct) auto

― ‹La demostración estructurada es›
lemma "n ∈ par ⟹ n - 2 ∈ par"
proof (induction rule:par.induct)
show "0 - 2 ∈ par" by auto
next
show "⋀n. ⟦n ∈ par; n - 2 ∈ par⟧ ⟹ Suc (Suc n) - 2 ∈ par" by auto
qed

text {*
Con el lema anterior se puede demostrar el original.
*}

― ‹La demostración aplicativa es›
lemma
"Suc (Suc n) ∈ par ⟹ n ∈ par"
apply (drule par_imp_par_menos_2)
(* Suc (Suc n) - 2 ∈ par ⟹ n ∈ par *)
apply simp
(* *)
done

― ‹La demostración automática es›
lemma Suc_Suc_par_imp_par:
"Suc (Suc n) ∈ par ⟹ n ∈ par"
by (drule par_imp_par_menos_2, simp)

― ‹La demostración declarativa es›
lemma
assumes "Suc (Suc n) ∈ par"
shows "n ∈ par"
proof -
have "Suc (Suc n) - 2 ∈ par"
using assms by (rule par_imp_par_menos_2)
then show "n ∈ par" by simp
qed

text {*
Lemma. Un número natural n es par syss n+2 es par.
*}

lemma [iff]: "((Suc (Suc n)) ∈ par) = (n ∈ par)"
by (blast dest: Suc_Suc_par_imp_par)

text {*
Se usa el atributo "iff" porque sirve como regla de simplificación.
*}

subsection {* Definiciones mutuamente inductivas *}

text {*
Definición cruzada de los conjuntos inductivos de los pares y de los
impares:
*}

inductive_set
Pares :: "nat set" and
Impares :: "nat set"
where
ceroP: "0 ∈ Pares"
| ParesI: "n ∈ Impares ⟹ Suc n ∈ Pares"
| ImparesI: "n ∈ Pares ⟹ Suc n ∈ Impares"

text {*
El esquema de inducción generado por la definición anterior es
· Pares_Impares.induct:
⟦P1 0;
⋀n. ⟦n ∈ Impares; P2 n⟧ ⟹ P1 (Suc n);
⋀n. ⟦n ∈ Pares; P1 n⟧ ⟹ P2 (Suc n)⟧
⟹ (x1 ∈ Pares ⟶ P1 x1) ∧ (x2 ∈ Impares ⟶ P2 x2)
*}

text {*
Ejemplo de demostración usando el esquema anterior.
*}

― ‹Demostración aplicativa›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
apply (induction rule: Pares_Impares.induct)
(* 1. even 0
2. ⋀n. ⟦n ∈ Impares; even (Suc n)⟧ ⟹ even (Suc n)
3. ⋀n. ⟦n ∈ Pares; even n⟧ ⟹ even (Suc (Suc n))*)
apply auto
(* *)
done

― ‹Demostración automática›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
by (induction rule: Pares_Impares.induct) auto

― ‹La demostración declarativa es›
lemma "(m ∈ Pares ⟶ even m) ∧ (n ∈ Impares ⟶ even (Suc n))"
proof (induction rule:Pares_Impares.induct)
show "even (0::nat)" by simp
next
fix n :: "nat"
assume H1: "n ∈ Impares" and
H2: "even (Suc n)"
show "even (Suc n)" using H2 by simp
next
fix n :: "nat"
assume H1: "n ∈ Pares" and
H2: "even n"
have "∃k. n = 2*k" using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k" ..
then have "Suc (Suc n) = 2*(k+1)" by auto
then have "∃k. Suc (Suc n) = 2*k" ..
then show "even (Suc (Suc n))" by (simp add: dvd_def)
qed

subsection {* Definición inductiva de predicados *}

text {*
Definición inductiva del predicado es_par tal que (es_par n) se
verifica si n es par.
*}

inductive es_par :: "nat ⇒ bool" where
"es_par 0"
| "es_par n ⟹ es_par (Suc(Suc n))"

text {*
Heurística para elegir entre definir conjuntos o predicados:
· si se va a combinar con operaciones conjuntistas, definir conjunto;
· en caso contrario, definir predicado.
*}

end
</source>

Razonamiento sobre árboles y bosques

2019-05-04T07:00:19Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 8: Razonamiento sobre árboles *}

theory T8_Razonamiento_sobre_arboles
imports Main HOL.Parity
begin

text {*
En este tema se estudia razonamiento sobre otras estructuras
recursivas como árboles binarios, árboles generales y bosques.

También se muestra cómo definir tipos de datos por recursión cruzada y
la demostración de sus propiedades por inducción.
*}

section {* Razonamiento sobre árboles binarios *}

text {*
Ejemplo de definición de tipos recursivos:
Definir un tipo de dato para los árboles binarios.
*}

datatype 'a arbolB = Hoja "'a"
| Nodo "'a" "'a arbolB" "'a arbolB"

text {*
Ejemplo de definición sobre árboles binarios:
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

fun espejo :: "'a arbolB ⇒ 'a arbolB" where
"espejo (Hoja x) = (Hoja x)"
| "espejo (Nodo x i d) = (Nodo x (espejo d) (espejo i))"

value "espejo (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
Nodo a (Hoja e) (Nodo b (Hoja d) (Hoja c))"

text {*
Ejemplo de demostración sobre árboles binarios:
Demostrar que la función "espejo" es involutiva; es decir, para
cualquier árbol a, se tiene que
espejo (espejo a) = a.
*}

― ‹La demostración aplicativa es›
lemma espejo_involutiva:
"espejo (espejo a ) = a"
apply (induct a)
(* 1. ⋀x. espejo (espejo (Hoja x)) = Hoja x
2. ⋀x1a a1 a2.
⟦espejo (espejo a1) = a1;
espejo (espejo a2) = a2⟧
⟹ espejo (espejo (Nodo x1a a1 a2)) = Nodo x1a a1 a2 *)
apply simp_all
(* *)
done

― ‹La demostración automática es›
lemma espejo_involutiva_2:
"espejo (espejo a ) = a"
by (induct a) simp_all

― ‹La demostración estructurada es›
lemma espejo_involutiva_3:
fixes a :: "'b arbolB"
shows "espejo (espejo a) = a" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "espejo (espejo (Nodo x i d)) =
espejo (Nodo x (espejo d) (espejo i))" by simp
also have "… = Nodo x (espejo (espejo i)) (espejo (espejo d))"
by simp
also have "… = Nodo x i d" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Comentarios sobre la demostración anterior:
· (fixes a :: "'b arbolB") es una abreviatura de "sea a1 un árbol binario
cuyos elementos son de tipo b".
· (induct a) indica que el método de demostración es por inducción
en el árbol binario a.
· Se generan dos casos:
1. ⋀a. espejo (espejo (Hoja a)) = Hoja a
2. ⋀a1 a2 a3. ⟦espejo (espejo a2) = a2;
espejo (espejo a3) = a3⟧
⟹ espejo (espejo (Nodo a1 a2 a3)) = Nodo a1 a2 a3
*}

text {*
Ejemplo. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.
*}

fun aplana :: "'a arbolB ⇒ 'a list" where
"aplana (Hoja x) = [x]"
| "aplana (Nodo x i d) = (aplana i) @ [x] @ (aplana d)"

value "aplana (Nodo a (Nodo b (Hoja c) (Hoja d)) (Hoja e)) =
[c, b, d, a, e]"

text {*
Ejemplo. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo a) = rev (aplana a)
*}

― ‹La demostración aplicativa es›
lemma "aplana (espejo a) = rev (aplana a)"
apply (induct a)
(* 1. ⋀x. aplana (espejo (Hoja x)) = rev (aplana (Hoja x))
2. ⋀x1a a1 a2.
⟦aplana (espejo a1) = rev (aplana a1);
aplana (espejo a2) = rev (aplana a2)⟧
⟹ aplana (espejo (Nodo x1a a1 a2)) =
rev (aplana (Nodo x1a a1 a2)) *)
apply simp_all
(* *)
done

― ‹La demostración automática es›
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a) simp_all

― ‹La demostración estructurada es›
lemma
fixes a :: "'b arbolB"
shows "aplana (espejo a) = rev (aplana a)" (is "?P a")
proof (induct a)
fix x
show "?P (Hoja x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (Nodo x i d)"
proof -
have "aplana (espejo (Nodo x i d)) =
aplana (Nodo x (espejo d) (espejo i))" by simp
also have "… = (aplana (espejo d)) @ [x] @ (aplana (espejo i))"
by simp
also have "… = (rev (aplana d)) @ [x] @ (rev (aplana i))"
using h1 h2 by simp
also have "… = rev ((aplana i) @ [x] @ (aplana d))" by simp
also have "… = rev (aplana (Nodo x i d))" by simp
finally show ?thesis .
qed
qed

section {* Árboles y bosques. Recursión mutua e inducción *}

text {*
Nota. [Ejemplo de definición de tipos mediante recursión cruzada]
· Un árbol de tipo a es una hoja o un nodo de tipo a junto con un
bosque de tipo a.
· Un bosque de tipo a es el boque vacío o un bosque contruido añadiendo
un árbol de tipo a a un bosque de tipo a.
*}

datatype 'a arbol = Hoja | Nodo "'a" "'a bosque"
and 'a bosque = Vacio | ConsB "'a arbol" "'a bosque"

text {*
Regla de inducción correspondiente a la recursión cruzada:
La regla de inducción sobre árboles y bosques es arbol_bosque.induct:
⟦P1 Hoja;
⋀x b. P2 b ⟹ P1 (Nodo x b);
P2 Vacio;
⋀a b. ⟦P1 a; P2 b⟧ ⟹ P2 (ConsB a b)⟧
⟹ P1 a ∧ P2 b
*}

text {*
Ejemplos de definición por recursión cruzada:
· aplana_arbol a) es la lista obtenida aplanando el árbol a.
· (aplana_bosque b) es la lista obtenida aplanando el bosque b.
· (map_arbol f a) es el árbol obtenido aplicando la función f a
todos los nodos del árbol a.
· (map_bosque f b) es el bosque obtenido aplicando la función f a
todos los nodos del bosque b.
*}

fun aplana_arbol :: "'a arbol ⇒ 'a list" and
aplana_bosque :: "'a bosque ⇒ 'a list" where
"aplana_arbol Hoja = []"
| "aplana_arbol (Nodo x b) = x # (aplana_bosque b)"
| "aplana_bosque Vacio = []"
| "aplana_bosque (ConsB a b) = (aplana_arbol a) @ (aplana_bosque b)"

fun map_arbol :: "('a ⇒ 'b) ⇒ 'a arbol ⇒ 'b arbol" and
map_bosque :: "('a ⇒ 'b) ⇒ 'a bosque ⇒ 'b bosque" where
"map_arbol f Hoja = Hoja"
| "map_arbol f (Nodo x b) = Nodo (f x) (map_bosque f b)"
| "map_bosque f Vacio = Vacio"
| "map_bosque f (ConsB a b) = ConsB (map_arbol f a) (map_bosque f b)"

text {*
Ejemplo de demostración por inducción cruzada:
Demostrar que:
· aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
· aplana_bosque (map_bosque f b) = map f (aplana_bosque b)
*}

declare [[names_short]]

― ‹La demostración aplicativa es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
apply (induct_tac a and b)
(* 1. aplana_arbol (map_arbol f Hoja) =
map f (aplana_arbol Hoja)
2. ⋀x1 x2.
aplana_bosque (map_bosque f x2) =
map f (aplana_bosque x2) ⟹
aplana_arbol (map_arbol f (Nodo x1 x2)) =
map f (aplana_arbol (Nodo x1 x2))
3. aplana_bosque (map_bosque f Vacio) =
map f (aplana_bosque Vacio)
4. ⋀x1 x2.
⟦aplana_arbol (map_arbol f x1) = map f (aplana_arbol x1);
aplana_bosque (map_bosque f x2) = map f (aplana_bosque x2)⟧
⟹ aplana_bosque (map_bosque f (ConsB x1 x2)) =
map f (aplana_bosque (ConsB x1 x2)) *)
apply simp_all
(* *)
done

― ‹La demostración automática es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
by (induct_tac a and b) simp_all

― ‹La demostración detallada es›
lemma "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)
∧ aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
proof (induct_tac a and b)
show "aplana_arbol (map_arbol f Hoja ) = map f (aplana_arbol Hoja)"
by simp
next
fix x b
assume HI: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_arbol (map_arbol f (Nodo x b)) =
aplana_arbol (Nodo (f x) (map_bosque f b))" by simp
also have "… = (f x) # (aplana_bosque (map_bosque f b))" by simp
also have "… = (f x) # (map f (aplana_bosque b))" using HI by simp
also have "… = map f (aplana_arbol (Nodo x b))" by simp
finally show "aplana_arbol (map_arbol f (Nodo x b))
= map f (aplana_arbol (Nodo x b))" .
next
show "aplana_bosque (map_bosque f Vacio) = map f (aplana_bosque Vacio)"
by simp
next
fix a b
assume HI1: "aplana_arbol (map_arbol f a) = map f (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque f b) = map f (aplana_bosque b)"
have "aplana_bosque (map_bosque f (ConsB a b)) =
aplana_bosque (ConsB (map_arbol f a) (map_bosque f b))" by simp
also have "… = aplana_arbol (map_arbol f a) @
aplana_bosque (map_bosque f b)"
by simp
also have "… = (map f (aplana_arbol a)) @ (map f (aplana_bosque b))"
using HI1 HI2 by simp
also have "… = map f (aplana_bosque (ConsB a b))" by simp
finally show "aplana_bosque (map_bosque f (ConsB a b))
= map f (aplana_bosque (ConsB a b))" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· (induct_tac a and b) indica que el método de demostración es por
inducción cruzada sobre a y b.
· Se generan 4 casos:
1. aplana_arbol (map_arbol arbol.Hoja h) = map h (aplana_arbol arbol.Hoja)
2. ⋀a bosque.
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque) ⟹
aplana_arbol (map_arbol (arbol.Nodo a bosque) h) =
map h (aplana_arbol (arbol.Nodo a bosque))
3. aplana_bosque (map_bosque Vacio h) = map h (aplana_bosque Vacio)
4. ⋀arbol bosque.
⟦aplana_arbol (map_arbol arbol h) = map h (aplana_arbol arbol);
aplana_bosque (map_bosque bosque h) = map h (aplana_bosque bosque)⟧
⟹ aplana_bosque (map_bosque (ConsB arbol bosque) h) =
map h (aplana_bosque (ConsB arbol bosque))
*}

end
</source>

Razonamiento por casos y por inducci¢n

2019-05-02T08:22:35Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 7: Razonamiento por casos y por inducción *}

theory T7_Razonamiento_por_casos_y_por_induccion
imports Main HOL.Parity
begin

text {*
En este tema se amplían los métodos de demostración por casos y por
inducción iniciados en el tema anterior.
*}

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Ejemplo de demostración por distinción de casos booleanos:
Demostrar "¬A ∨ A".
*}

― ‹La demostración aplicativa es›
lemma "¬A ∨ A"
apply cases (* 1. ?P ⟹ ¬ A ∨ A
2. ¬ ?P ⟹ ¬ A ∨ A *)
apply (erule disjI2) (* 1. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI1) (* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "¬A ∨ A"
apply cases (* 1. ?P ⟹ ¬ A ∨ A
2. ¬ ?P ⟹ ¬ A ∨ A *)
apply simp_all (* No subgoals! *)
done

― ‹La demostración automática es›
lemma "¬A ∨ A"
by simp

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof cases
assume "A"
then show "¬A ∨ A" ..
next
assume "¬A"
then show "¬A ∨ A" ..
qed

text {*
Comentarios de la demostración anterior:
· "proof cases" indica que el método de demostración será por
distinción de casos.
· Se generan 2 casos:
1. ?P ⟹ ¬A ∨ A
2. ¬?P ⟹ ¬A ∨ A
donde ?P es una variable sobre las fórmulas.
· (assume "A") indica que se está usando "A" en lugar de la variable
?P.
· "then" indica usando la fórmula anterior.
· ".." indica usando la regla lógica necesaria (las reglas lógicas se
estudiarán en los siguientes temas).
· "next" indica el siguiente caso (se puede observar cómo ha
sustituido ¬?P por ¬A.
*}

text {*
Ejemplo de demostración por distinción de casos booleanos con nombres:
Demostrar "¬A ∨ A".
*}

― ‹La demostración aplicativa es›
lemma "¬A ∨ A"
apply (cases "A") (* 1. A ⟹ ¬ A ∨ A
2. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI2) (* 1. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI1) (* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "¬A ∨ A"
apply (cases "A") (* 1. A ⟹ ¬ A ∨ A
2. ¬ A ⟹ ¬ A ∨ A *)
apply simp_all (* No subgoals! *)
done

― ‹La demostración automática es›
lemma "¬A ∨ A"
by simp

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof (cases "A")
case True
then show "¬A ∨ A" ..
next
case False
thus "¬A ∨ A" ..
qed

text {*
Comentarios sobre la demostración anterior:
· (cases "A") indica que la demostración se hará por casos según los
distintos valores de "A".
· Como "A" es una fórmula, sus posibles valores son verdadero o falso.
· "case True" indica que se está suponiendo que A es verdadera. Es
equivalente a "assume A".
· "case False" indica que se está suponiendo que A es falsa. Es
equivalente a "assume ¬A".
· En general,
· el método (cases F) es una abreviatura de la aplicación de la regla
⟦F ⟹ Q; ¬F ⟹ Q⟧ ⟹ Q
· La expresión "case True" es una abreviatura de F.
· La expresión "case False" es una abreviatura de ¬F.
· Ventajas de "cases" con nombre:
· reduce la escritura de la fórmula y
· es independiente del orden de los casos.
*}

subsection {* Distinción de casos sobre otros tipos de datos *}

text {*
Ejemplo de distinción de casos sobre listas:
Demostrar que la longitud del resto de una lista es la longitud de la
lista menos 1.
*}

― ‹La demostración aplicativa es›
lemma "length (tl xs) = length xs - 1"
apply (cases xs)
(* 1. xs = [] ⟹ length (tl xs) = length xs - 1
2. ⋀a list. xs = a # list ⟹
length (tl xs) = length xs - 1*)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "length (tl xs) = length xs - 1"
by (cases xs) simp_all

― ‹La demostración automática es›
lemma "length (tl xs) = length xs - 1"
by auto

― ‹La demostración detallada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
assume "xs = []"
then show "length (tl xs) = length xs - 1" by simp
next
fix y ys
assume "xs = y#ys"
then show "length(tl xs) = length xs - 1" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "(cases xs)" indica que la demostración se hará por casos sobre los
posibles valores de xs.
· Como xs es una lista, sus posibles valores son la lista vacía ([]) o
una lista no vacía (de la forma (y#ys)).
· Se generan 2 casos:
1. xs = [] ⟹ length (tl xs) = length xs - 1
2. ⋀a list. xs = a # list ⟹ length (tl xs) = length xs - 1
*}

― ‹La demostración simplificada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de
"assume xs =[]".
· "case Cons" es una abreviatura de
"fix y ys assume xs = y#ys"
· ?thesis es una abreviatura de la conclusión del lema.
*}

text {*
En el siguiente ejemplo vamos a demostrar una propiedad de la función
drop que está definida en la teoría List de forma que (drop n xs) la
lista obtenida eliminando en xs} los n primeros elementos. Su
definición es la siguiente
drop_Nil: "drop n [] = []"
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

text {*
Ejemplo de análisis de casos:
Demostrar que el resultado de eliminar los n+1 primeros elementos de
xs es el mismo que eliminar los n primeros elementos del resto de xs.
*}

― ‹La demostración aplicativa es›
lemma "drop (n + 1) xs = drop n (tl xs)"
apply (cases xs)
(* 1. xs = [] ⟹ drop (n + 1) xs = drop n (tl xs)
2. ⋀a list. xs = a # list ⟹
drop (n + 1) xs = drop n (tl xs) *)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración automática es›
lemma "drop (n + 1) xs = drop n (tl xs)"
by (cases xs) auto

― ‹La demostración detallada es›
lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

section {* Inducción matemática *}

text {*
[Principio de inducción matemática]
Para demostrar una propiedad P para todos los números naturales basta
probar que el 0 tiene la propiedad P y que si n tiene la propiedad P,
entonces n+1 también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción matemática está formalizado en
el teorema nat.induct y puede verse con
thm nat.induct
*}

text {*
Ejemplo de demostración por inducción: Usaremos el principio de
inducción matemática para demostrar que
1 + 3 + ... + (2n-1) = n^2

Definición. [Suma de los primeros impares]
(suma_impares n) la suma de los n números impares. Por ejemplo,
suma_impares 3 = 9
*}

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

value "suma_impares 3"

text {*
Ejemplo de demostración por inducción matemática:
Demostrar que la suma de los n primeros números impares es n^2.
*}

― ‹La demostración aplicativa es›
lemma "suma_impares n = n * n"
apply (induct n)
(* 1. suma_impares 0 = 0 * 0
2. ⋀n. suma_impares n = n * n ⟹
suma_impares (Suc n) = Suc n * Suc n*)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración automática es›
lemma "suma_impares n = n * n"
by (induct n) simp_all

― ‹Demostración del lema anterior por inducción y razonamiento
ecuacional›
lemma "suma_impares n = n * n"
proof (induct n)
show "suma_impares 0 = 0 * 0" by simp
next
fix n assume HI: "suma_impares n = n * n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n" using HI by simp
also have "… = n * n + 2 * n + 1" by simp
finally show "suma_impares (Suc n) = (Suc n) * (Suc n)" by simp
qed

― ‹Demostración del lema anterior con patrones y razonamiento
ecuacional›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n" using HI by simp
also have "… = n * n + 2 * n + 1" by simp
finally show "?P (Suc n)" by simp
qed

text {*
Comentario sobre la demostración anterior:
· Con la expresión
"suma_impares n = n * n" (is "?P n")
se abrevia "suma_impares n = n * n" como "?P n". Por tanto,
"?P 0" es una abreviatura de "suma_impares 0 = 0 * 0"
"?P (Suc n)" es una abreviatura de "suma_impares (Suc n) =
(Suc n) * (Suc n)"
· En general, cualquier fórmula seguida de (is patrón) equipara el
patrón con la fórmula.
*}

― ‹La demostración usando patrones es›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume "?P n"
then show "?P (Suc n)" by simp
qed

text {*
Ejemplo de definición con existenciales.
Un número natural n es par si existe un natural m tal que n=m+m.
*}

definition par :: "nat ⇒ bool" where
"par n ≡ ∃m. n=m+m"

text {*
Ejemplo de inducción y existenciales:
Demostrar que para todo número natural n, se verifica que n*(n+1) par.
*}

― ‹Demostración aplicativa›
lemma
shows "par (n*(n+1))"
apply (induct n)
(* par (0 * (0 + 1))
⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. ∃m. n + n * n = m + m ⟹
∃m. Suc (Suc (n + (n + (n + n * n)))) = m + m *)
apply (erule exE)
(* ⋀n m. n + n * n = m + m ⟹
∃m. Suc (Suc (n + (n + (n + n * n)))) = m + m*)
apply (rule_tac x="m+n+1" in exI)
(* ⋀n m. n + n * n = m + m ⟹
Suc (Suc (n + (n + (n + n * n)))) =
m + n + 1 + (m + n + 1)*)
apply simp
(* *)
done

― ‹Demostración aplicativa con arith›
lemma
shows "par (n*(n+1))"
apply (induct n)
(* par (0 * (0 + 1))
⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. ∃m. n + n * n = m + m ⟹
∃m. Suc (Suc (n + (n + (n + n * n)))) = m + m *)
apply arith
(* *)
done

― ‹Demostración automática›
lemma
fixes n :: "nat"
shows "par (n*(n+1))"
by (induct n) (auto simp add: par_def, arith)

― ‹Demostración declarativa›
lemma
fixes n :: "nat"
shows "par (n*(n+1))"
proof (induct n)
show "par (0*(0+1))" by (simp add: par_def)
next
fix n
assume "par (n*(n+1))"
then have "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" ..
then have "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
then have "∃m. (Suc n)*((Suc n)+1) = m+m" ..
then show "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

text {*
Comentarios sobre la demostración anterior:
· (fixes n :: "nat") es una abreviatura de "sea n un número natural".
*}

text {*
En Isabelle puede demostrarse de manera más simple un lema equivalente
usando en lugar de la función "par" la función "even" definida en la
teoría Parity por
even x ⟷ x mod 2 = 0"
*}

lemma
fixes n :: "nat"
shows "even (n*(n+1))"
by auto

text {*
Comentarios sobre la demostración anterior:
· Para poder usar la función "even" de la librería Parity es necesario
importar dicha librería. Por ello, antes del inicio de la teoría
aparece
imports Main HOL.Parity
*}

text {*
Para completar la demostración basta demostrar la equivalencia de las
funciones "par" y "even".
*}

― ‹Demostración aplicativa›
lemma
shows "par n = even n"
apply (simp add: par_def) (* (∃m. n = m + m) = even n *)
apply presburger (* *)
done

― ‹Demostración automática›
lemma
shows "par n = even n"
by (simp add: par_def, presburger)

― ‹Demostración declarativa›
lemma
fixes n :: "nat"
shows "par n = even n"
proof -
have "par n = (∃m. n = m+m)" by (simp add:par_def)
then show "par n = even n" by presburger
qed

text {*
Comentarios sobre la demostración anterior:
· "by presburger" indica que se use como método de demostración el
algoritmo de decisión de la aritmética de Presburger.
*}

section {* Inducción estructural *}

text {*
Inducción estructural:
· En Isabelle puede hacerse inducción estructural sobre cualquier tipo
recursivo.
· La inducción matemática es la inducción estructural sobre el tipo de
los naturales.
· El esquema de inducción estructural sobre listas es
· list.induct: ⟦P []; ⋀x ys. P ys ⟹ P (x # ys)⟧ ⟹ P zs
· Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a una
lista que tiene la propiedad se obtiene una lista que también tiene la
propiedad.
· En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct que puede verse con
thm list.induct
*}

text {*
Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"
*}

text {*
Lema. [Ejemplo de inducción sobre listas]
Demostrar que la concatenación de listas es asociativa.
*}

― ‹La demostración automática es›
lemma conc_asociativa: "xs @ (ys @ zs) = (xs @ ys) @ zs"
apply (induct xs)
(* 1. [] @ (ys @ zs) = ([] @ ys) @ zs
2. ⋀a xs. xs @ (ys @ zs) = (xs @ ys) @ zs ⟹
(a # xs) @ (ys @ zs) = ((a # xs) @ ys) @ zs*)
apply simp_all
(* *)
done

― ‹La demostración automática es›
lemma conc_asociativa_2: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

― ‹La demostración estructurada es›
lemma conc_asociativa_3: "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
show "[] @ (ys @ zs) = ([] @ ys) @ zs"
proof -
have "[] @ (ys @ zs) = ys @ zs" by simp
also have "… = ([] @ ys) @ zs" by simp
finally show ?thesis .
qed
next
fix x xs
assume HI: "xs @ (ys @ zs) = (xs @ ys) @ zs"
show "(x#xs) @ (ys @ zs) = ((x#xs) @ ys) @ zs"
proof -
have "(x#xs) @ (ys @ zs) = x#(xs @ (ys @ zs))" by simp
also have "… = x#((xs @ ys) @ zs)" using HI by simp
also have "… = (x#(xs @ ys)) @ zs" by simp
also have "… = ((x#xs) @ ys) @ zs" by simp
finally show ?thesis .
qed
qed

section {* Recursión general. La función de Ackermann *}

text {*
El objetivo de esta sección es mostrar el uso de las definiciones
recursivas generales y sus esquemas de inducción. Como ejemplo se usa la
función de Ackermann (se puede consultar información sobre dicha función en
http://en.wikipedia.org/wiki/Ackermann_function).

Definición. La función de Ackermann se define por
A(m,n) = n+1, si m=0,
A(m-1,1), si m>0 y n=0,
A(m-1,A(m,n-1)), si m>0 y n>0
para todo los números naturales.

La función de Ackermann es recursiva, pero no es primitiva recursiva.
*}

fun ack :: "nat ⇒ nat ⇒ nat" where
"ack 0 n = n+1"
| "ack (Suc m) 0 = ack m 1"
| "ack (Suc m) (Suc n) = ack m (ack (Suc m) n)"

― ‹Ejemplo de evaluación›
value "ack 2 3" (* devuelve 9 *)

text {*
Esquema de inducción correspondiente a una función:
· Al definir una función recursiva general se genera una regla de
inducción. En la definición anterior, la regla generada es
ack.induct:
⟦⋀n. P 0 n;
⋀m. P m 1 ⟹ P (Suc m) 0;
⋀m n. ⟦P (Suc m) n; P m (ack (Suc m) n)⟧ ⟹ P (Suc m) (Suc n)⟧
⟹ P a b
*}

text {*
Ejemplo de demostración por la inducción correspondiente a una función:
Demostrar que para todos m y n, A(m,n) > n.
*}

― ‹Demostración aplicativa›
lemma "ack m n > n"
apply (induct m n rule: ack.induct)
(* 1. ⋀n. n < ack 0 n
2. ⋀m. 1 < ack m 1 ⟹ 0 < ack (Suc m) 0
3. ⋀m n. ⟦n < ack (Suc m) n;
ack (Suc m) n < ack m (ack (Suc m) n)⟧
⟹ Suc n < ack (Suc m) (Suc n) *)
apply simp_all
done

― ‹Demostración automática›
lemma "ack m n > n"
by (induct m n rule: ack.induct) simp_all

― ‹Demostración declarativa›
lemma "ack m n > n"
proof (induct m n rule: ack.induct)
fix n
show "ack 0 n > n" by simp
next
fix m
assume "ack m 1 > 1"
then show "ack (Suc m) 0 > 0" by simp
next
fix m n
assume "n < ack (Suc m) n" and
"ack (Suc m) n < ack m (ack (Suc m) n)"
then show "Suc n < ack (Suc m) (Suc n)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· (induct m n rule: ack.induct) indica que el método de demostración
es el esquema de recursión correspondiente a la definición de
(ack m n).
· Se generan 3 casos:
1. ⋀n. n < ack 0 n
2. ⋀m. 1 < ack m 1 ⟹ 0 < ack (Suc m) 0
3. ⋀m n. ⟦n < ack (Suc m) n;
ack (Suc m) n < ack m (ack (Suc m) n)⟧
⟹ Suc n < ack (Suc m) (Suc n)
*}

end
</source>

Razonamiento sobre programas en Isabelle/HOL

2019-05-02T06:40:43Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 6: Razonamiento sobre programas *}

theory T6_Razonamiento_sobre_programas
imports Main
begin

text {*
En este tema se demuestra con Isabelle las propiedades de los
programas funcionales de tema 6 http://bit.ly/2Za6YWY

Para cada propiedades se presentan distintos tipos de demostraciones:
automáticas, aplicativas y declarativas. *}

declare [[names_short]]

section {* Razonamiento ecuacional *}

text {* ----------------------------------------------------------------
Ejemplo 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 [a,c,d] = 3
------------------------------------------------------------------- *}

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

value "longitud [a,c,d] = 3"

text {* ---------------------------------------------------------------
Ejemplo 2. Demostrar que
longitud [a,c,d] = 3
------------------------------------------------------------------- *}

lemma "longitud [a,c,d] = 3"
apply simp
done

lemma "longitud [a,c,d] = 3"
by simp

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

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

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

text {*
La definición de la función intercambia genera una regla de
simplificación
· intercambia.simps: intercambia (x,y) = (y,x)

Se puede ver con
· thm intercambia.simps
*}

thm intercambia.simps
(* da intercambia (?x, ?y) = (?y, ?x) *)

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

(* Demostración automática *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by auto

(* Demostración automática 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

(* Demostración automática 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by (simp only: intercambia.simps)

(* Demostración aplicativa *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
apply (simp only: intercambia.simps)
done

(* Demostración declarativa 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)" by simp
also have "... = (x,y)" by simp
finally show "intercambia (intercambia (x,y)) = (x,y)" by simp
qed

(* Demostración declarativa 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by (simp only: intercambia.simps)
also have "... = (x,y)"
by (simp only: intercambia.simps)
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

text {*
Notas sobre el lenguaje: En la demostración anterior se ha usado
· "proof" para iniciar la prueba,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "by (simp only: intercambia.simps)" para indicar que sólo se usa
como regla de escritura la correspondiente a la definición de
intercambia,
· "also" para encadenar pasos ecuacionales,
· "..." para representar la derecha de la igualdad anterior en un
razonamiento ecuacional,
· "finally" para indicar el último pasa de un razonamiento ecuacional,
· "show" para establecer la conclusión.
· "by simp" para indicar el método de demostración por simplificación y
· "qed" para terminar la pruebas,
*}

text {*
Nota: La diferencia entre las dos demostraciones es que en los dos
primeros pasos no se explicita la regla de simplificación.
*}

text {* ---------------------------------------------------------------
Ejemplo 5. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [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 {* ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

(* La demostración automática es *)
lemma "inversa [x] = [x]"
by simp

(* La demostración aplicativa es *)
lemma "inversa [x] = [x]"
apply simp
done

text {*
En la demostración anterior se usaron las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
Vamos a explicitar su aplicación.
*}

(* La demostración aplicativa detallada es *)
lemma "inversa [x] = [x]"
apply (simp only: inversa.simps(2)) (* inversa [] @ [x] = [x] *)
apply (simp only: inversa.simps(1)) (* [] @ [x] = [x] *)
apply (simp only: append_Nil) (* No subgoals! *)
done

(* La demostración declarativa es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by (simp only: inversa.simps(2))
also have "... = [] @ [x]" by (simp only: inversa.simps(1))
also have "... = [x]" by (simp only: append_Nil)
finally show "inversa [x] = [x]" by simp
qed

(* La demostración declarativa simplificada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by simp
also have "... = [] @ [x]" by simp
also have "... = [x]" by simp
finally show "inversa [x] = [x]" by simp
qed

section {* Razonamiento por inducción sobre los naturales *}

text {*
[Principio de inducción sobre los naturales] Para demostrar una
propiedad P para todos los números naturales basta probar que el 0
tiene la propiedad P y que si n tiene la propiedad P, entonces n+1
también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción sobre los naturales está
formalizado en el teorema nat.induct y puede verse con
thm nat.induct
*}

text {* ---------------------------------------------------------------
Ejemplo 7. 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 {* ---------------------------------------------------------------
Ejemplo 8. (p. 18) Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* 1. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* No subgoals *)
done

(* La demostración aplicativa con simp_all es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp_all (* No subgoals *)
done

(* La demostración automática es *)
lemma "longitud (repite n x) = n"
by (induct n) simp_all

(* La demostración declarativa es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0" by simp
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by simp
also have "... = 1 + longitud (repite n x)" by simp
also have "... = 1 + n" using HI by simp
finally show "longitud (repite (Suc n) x) = Suc n" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· A la derecha de proof se indica el método de la demostración.
· (induct n) indica que la demostración se hará por inducción en n.
· Se generan dos subobjetivos correspondientes a la base y el paso de
inducción:
1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n
donde ⋀n se lee "para todo n".
· "next" indica el siguiente subobjetivo.
· "fix n" indica "sea n un número natural cualquiera"
· assume HI: "longitud (repite n x) = n" indica «supongamos que
"longitud (repite n x) = n" y sea HI la etiqueta de este supuesto».
· "using HI" usando la propiedad etiquetada con HI.
*}

section {* Razonamiento por inducción sobre listas *}

text {*
Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a
una lista que tiene la propiedad se obtiene otra lista que también
tiene la propiedad.

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct
⟦P [];
⋀x xs. P xs ⟹ P (x#xs)⟧
⟹ P xs
*}

text {* ---------------------------------------------------------------
Ejemplo 9. 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 {* ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs) (* 1. conc [] (conc ys zs) = conc (conc [] ys) zs
2. ⋀a xs.
conc xs (conc ys zs) =
conc (conc xs ys) zs ⟹
conc (a # xs) (conc ys zs) =
conc (conc (a # xs) ys) zs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs" by simp
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))" by simp
also have "... = x # (conc (conc xs ys) zs)" using HI by simp
also have "... = conc (conc (x # xs) ys) zs" by simp
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by simp
qed

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

lemma "conc xs ys = conc ys xs"
quickcheck
oops

text {* Encuentra el contraejemplo,
xs = [a2]
ys = [a1] *}

text {* ---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs [] = xs"
apply (induct xs) (* 1. conc [] [] = []
2. ⋀a xs.
conc xs [] = xs ⟹
conc (a # xs) [] = a # xs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs [] = xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x xs
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])" by simp
also have "... = x # xs" using HI by simp
finally show "conc (x # xs) [] = x # xs" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs) (* 1. longitud (conc [] ys) =
longitud [] + longitud ys
2. ⋀a xs.
longitud (conc xs ys) =
longitud xs + longitud ys ⟹
longitud (conc (a # xs) ys) =
longitud (a # xs) + longitud ys *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys" by simp
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by simp
also have "... = 1 + longitud (conc xs ys)" by simp
also have "... = 1 + longitud xs + longitud ys" using HI by simp
also have "... = longitud (x # xs) + longitud ys" by simp
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys" by simp
qed

section {* Inducción correspondiente a la definición recursiva *}

text {* ---------------------------------------------------------------
Ejemplo 14. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [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 {* ---------------------------------------------------------------
Ejemplo 15. 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 {*
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". *}

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

(* La demostración aplicativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
(* 1. ⋀n. conc (coge n []) (elimina n []) = []
2. ⋀v va. conc (coge 0 (v # va)) (elimina 0 (v # va)) =
v # va
3. ⋀n x xs. conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x # xs))
(elimina (Suc n) (x # xs)) =
x # xs *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) simp_all

(* La demostración declarativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []" by simp
next
fix x xs
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs" by simp
next
fix n x xs
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)" by simp
also have "... = x#(conc (coge n xs) (elimina n xs))" by simp
also have "... = x#xs" using HI by simp
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by simp
qed

text {*
Comentario sobre la demostración anterior:
· (induct rule: coge.induct) indica que el método de demostración es
por el esquema de inducción correspondiente a la definición de la
función coge.
· Se generan 3 subobjetivos:
· 1. ⋀n. conc (coge n []) (elimina n []) = []
· 2. ⋀x xs. conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs
· 3. ⋀n x xs.
conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) = x#xs
*}

section {* Razonamiento por casos *}

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

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

value "esVacia [] = True"
value "esVacia [a] = False"

text {* ---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
(* 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
2. ⋀a list. xs = a # list ⟹
esVacia xs = esVacia (conc xs xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) simp_all

(* La demostración declarativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "(cases xs)" es el método de demostración por casos según xs.
· Se generan dos subobjetivos correspondientes a los dos
constructores de listas:
· 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
· 2. ⋀y ys. xs = y#ys ⟹ esVacia xs = esVacia (conc xs xs)
· "then" indica "usando la propiedad anterior"
*}

(* La demostración declarativa simplificada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
case Cons
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de "assume xs = []"
· "case Cons" es una abreviatura de "fix y ys assume xs = y#ys"
· "thus" es una abreviatura de "then show".
*}

(* La demostración con el patrón sugerido es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case (Cons x xs)
then show ?thesis by simp
qed

section {* Heurística de generalización *}

text {* ---------------------------------------------------------------
Ejemplo 19. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [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)"

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

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

text {*
Lema. [Ejemplo de equivalencia entre las definiciones]
La inversa de [a,b,c] es lo mismo calculada con la primera definición
que con la segunda.
*}

lemma "inversaAc [a,b,c] = inversa [a,b,c]"
by (simp add: inversaAc_def)

text {*
Nota. [Ejemplo fallido de demostración por inducción]
El siguiente intento de demostrar que para cualquier lista xs, se
tiene que "inversaAc xs = inversa xs" falla.
*}

lemma "inversaAc xs = inversa xs"
proof (induct xs)
show "inversaAc [] = inversa []" by (simp add: inversaAc_def)
next
fix a xs assume HI: "inversaAc xs = inversa xs"
have "inversaAc (a#xs) = inversaAcAux (a#xs) []"
by (simp add: inversaAc_def)
also have "… = inversaAcAux xs [a]" by simp
also have "… = inversa (a#xs)"
(* Problema: la hipótesis de inducción no es aplicable. *)
oops

text {*
Nota. [Heurística de generalización]
Cuando se use demostración estructural, cuantificar universalmente las
variables libres (o, equivalentemente, considerar las variables libres
como variables arbitrarias).

Lema. [Lema con generalización]
Para toda lista ys se tiene
inversaAcAux xs ys = (inversa xs) @ ys
*}

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

(* La demostración aplicativa es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
(* 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
2. ⋀a xs ys.
(⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) simp_all

(* La demostración declarativa es *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = (inversa [])@ys" by simp
next
fix a xs
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)" by simp
also have "… = inversa xs@(a#ys)" using HI by simp
also have "… = inversa (a#xs)@ys" using [[simp_trace]] by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys" by simp
qed
qed

text {*
Comentarios sobre la demostración anterior:
· "(induct xs arbitrary: ys)" es el método de demostración por
inducción sobre xs usando ys como variable arbitraria.
· Se generan dos subobjetivos:
· 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
· 2. ⋀a xs ys. (⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys
· Dentro de una demostración se pueden incluir otras demostraciones.
· Para demostrar la propiedad universal "⋀ys. P(ys)" se elige una
lista arbitraria (con "fix ys") y se demuestra "P(ys)".
*}

text {*
Nota. En el paso "inversa xs@(a#ys) = inversa (a#xs)@ys" se usan
lemas de la teoría List. Se puede observar, insertano
using [[simp_trace]]
entre la igualdad y by simp, que los lemas usados son
· List.append_simps_1: []@ys = ys
· List.append_simps_2: (x#xs)@ys = x#(xs@ys)
· List.append_assoc: (xs @ ys) @ zs = xs @ (ys @ zs)
Las dos primeras son las ecuaciones de la definición de append.

En la siguiente demostración se detallan los lemas utilizados.
*}

― ‹Demostración aplicativa›
lemma "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
apply (simp only: inversa.simps(2))
(* inversa xs @ (a # ys) = (inversa xs @ [a]) @ ys*)
apply (simp only: append_assoc)
(* inversa xs @ (a # ys) = inversa xs @ ([a] @ ys) *)
apply (simp only: append.simps(2))
(* inversa xs @ (a # ys) = inversa xs @ (a # ([] @ ys)) *)
apply (simp only: append.simps(1))
(* *)
done

― ‹Demostración declarativa›
lemma "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
proof -
have "(inversa xs)@(a#ys) = (inversa xs)@(a#([]@ys))"
by (simp only: append.simps(1))
also have "… = (inversa xs)@([a]@ys)" by (simp only: append.simps(2))
also have "… = ((inversa xs)@[a])@ys" by (simp only: append_assoc)
also have "… = (inversa (a#xs))@ys" by (simp only: inversa.simps(2))
finally show ?thesis .
qed

text {* ---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
corollary "inversaAc xs = inversa xs"
apply (simp add: inversaAcAux_es_inversa inversaAc_def)
done

(* La demostración automática es *)
corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa inversaAc_def)

text {*
Comentario de la demostración anterior:
· "(simp add: inversaAcAux_es_inversa inversaAc_def)" es el método de
demostración por simplificación usando como regla de simplificación
las propiedades inversaAcAux_es_inversa e inversaAc_def.
*}

section {* Demostración por inducción para funciones de orden superior *}

text {* ---------------------------------------------------------------
Ejemplo 22. 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 {* ---------------------------------------------------------------
Ejemplo 23. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3::nat,2,5] = [6,4,10]
map (( * ) 2) [3::nat,2,5] = [6,4,10]
map ((+) 2) [3::nat,2,5] = [5,4,7]
------------------------------------------------------------------ *}

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]"
value "map (( * ) 2) [3::nat,2,5] = [6,4,10]"
value "map ((+) 2) [3::nat,2,5] = [5,4,7]"

text {* ---------------------------------------------------------------
Ejemplo 24. (p. 45) Demostrar que
sum (map (( * ) 2) xs) = 2 * (sum xs)
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
apply (induct xs)
(* 1. sum (map (( * ) 2) []) = 2 * sum []
2. ⋀a xs. sum (map (( * ) 2) xs) = 2 * sum xs ⟹
sum (map (( * ) 2) (a # xs)) = 2 * sum (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map (( * ) 2) []) = 2 * (sum [])" by simp
next
fix a xs
assume HI: "sum (map (( * ) 2) xs) = 2 * (sum xs)"
have "sum (map (( * ) 2) (a#xs)) = sum ((2*a)#(map (( * ) 2) xs))"
by simp
also have "... = 2*a + sum (map (( * ) 2) xs)" by simp
also have "... = 2*a + 2*(sum xs)" using HI by simp
also have "... = 2*(a + sum xs)" by simp
also have "... = 2*(sum (a#xs))" by simp
finally show "sum (map (( * ) 2) (a#xs)) = 2*(sum (a#xs))" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
(* 1. longitud (map f []) = longitud []
2. ⋀a xs. longitud (map f xs) = longitud xs ⟹
longitud (map f (a # xs)) = longitud (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []" by simp
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))" by simp
also have "... = 1 + longitud (map f xs)" by simp
also have "... = 1 + longitud xs" using HI by simp
also have "... = longitud (a#xs)" by simp
finally show "longitud (map f (a#xs)) = longitud (a#xs)" by simp
qed

section {* Referencias *}

text {*
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms".
· S. Thompson. "Haskell: the Craft of Functional Programming, 3rd
Edition. Cap. 8 "Reasoning about programms".
· L. Paulson. "ML for the Working Programmer, 2nd Edition". Cap. 6.
"Reasoning about functional programs".
*}

end
</source>

Razonamiento por casos y por inducci¢n

2019-05-01T14:45:22Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 7: Razonamiento por casos y por inducción *}

theory T7_Razonamiento_por_casos_y_por_induccion
imports Main HOL.Parity
begin

text {*
En este tema se amplían los métodos de demostración por casos y por
inducción iniciados en el tema anterior.
*}

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Ejemplo de demostración por distinción de casos booleanos:
Demostrar "¬A ∨ A".
*}

― ‹La demostración aplicativa es›
lemma "¬A ∨ A"
apply cases (* 1. ?P ⟹ ¬ A ∨ A
2. ¬ ?P ⟹ ¬ A ∨ A *)
apply (erule disjI2) (* 1. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI1) (* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "¬A ∨ A"
apply cases (* 1. ?P ⟹ ¬ A ∨ A
2. ¬ ?P ⟹ ¬ A ∨ A *)
apply simp_all (* No subgoals! *)
done

― ‹La demostración automática es›
lemma "¬A ∨ A"
by simp

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof cases
assume "A"
then show "¬A ∨ A" ..
next
assume "¬A"
then show "¬A ∨ A" ..
qed

text {*
Comentarios de la demostración anterior:
· "proof cases" indica que el método de demostración será por
distinción de casos.
· Se generan 2 casos:
1. ?P ⟹ ¬A ∨ A
2. ¬?P ⟹ ¬A ∨ A
donde ?P es una variable sobre las fórmulas.
· (assume "A") indica que se está usando "A" en lugar de la variable
?P.
· "then" indica usando la fórmula anterior.
· ".." indica usando la regla lógica necesaria (las reglas lógicas se
estudiarán en los siguientes temas).
· "next" indica el siguiente caso (se puede observar cómo ha
sustituido ¬?P por ¬A.
*}

text {*
Ejemplo de demostración por distinción de casos booleanos con nombres:
Demostrar "¬A ∨ A".
*}

― ‹La demostración aplicativa es›
lemma "¬A ∨ A"
apply (cases "A") (* 1. A ⟹ ¬ A ∨ A
2. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI2) (* 1. ¬ A ⟹ ¬ A ∨ A *)
apply (erule disjI1) (* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "¬A ∨ A"
apply (cases "A") (* 1. A ⟹ ¬ A ∨ A
2. ¬ A ⟹ ¬ A ∨ A *)
apply simp_all (* No subgoals! *)
done

― ‹La demostración automática es›
lemma "¬A ∨ A"
by simp

― ‹La demostración estructurada es›
lemma "¬A ∨ A"
proof (cases "A")
case True
then show "¬A ∨ A" ..
next
case False
thus "¬A ∨ A" ..
qed

text {*
Comentarios sobre la demostración anterior:
· (cases "A") indica que la demostración se hará por casos según los
distintos valores de "A".
· Como "A" es una fórmula, sus posibles valores son verdadero o falso.
· "case True" indica que se está suponiendo que A es verdadera. Es
equivalente a "assume A".
· "case False" indica que se está suponiendo que A es falsa. Es
equivalente a "assume ¬A".
· En general,
· el método (cases F) es una abreviatura de la aplicación de la regla
⟦F ⟹ Q; ¬F ⟹ Q⟧ ⟹ Q
· La expresión "case True" es una abreviatura de F.
· La expresión "case False" es una abreviatura de ¬F.
· Ventajas de "cases" con nombre:
· reduce la escritura de la fórmula y
· es independiente del orden de los casos.
*}

subsection {* Distinción de casos sobre otros tipos de datos *}

text {*
Ejemplo de distinción de casos sobre listas:
Demostrar que la longitud del resto de una lista es la longitud de la
lista menos 1.
*}

― ‹La demostración aplicativa es›
lemma "length (tl xs) = length xs - 1"
apply (cases xs)
(* 1. xs = [] ⟹ length (tl xs) = length xs - 1
2. ⋀a list. xs = a # list ⟹
length (tl xs) = length xs - 1*)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración semiautomática es›
lemma "length (tl xs) = length xs - 1"
by (cases xs) simp_all

― ‹La demostración automática es›
lemma "length (tl xs) = length xs - 1"
by auto

― ‹La demostración detallada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
assume "xs = []"
then show "length (tl xs) = length xs - 1" by simp
next
fix y ys
assume "xs = y#ys"
then show "length(tl xs) = length xs - 1" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "(cases xs)" indica que la demostración se hará por casos sobre los
posibles valores de xs.
· Como xs es una lista, sus posibles valores son la lista vacía ([]) o
una lista no vacía (de la forma (y#ys)).
· Se generan 2 casos:
1. xs = [] ⟹ length (tl xs) = length xs - 1
2. ⋀a list. xs = a # list ⟹ length (tl xs) = length xs - 1
*}

― ‹La demostración simplificada es›
lemma "length (tl xs) = length xs - 1"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de
"assume xs =[]".
· "case Cons" es una abreviatura de
"fix y ys assume xs = y#ys"
· ?thesis es una abreviatura de la conclusión del lema.
*}

text {*
En el siguiente ejemplo vamos a demostrar una propiedad de la función
drop que está definida en la teoría List de forma que (drop n xs) la
lista obtenida eliminando en xs} los n primeros elementos. Su
definición es la siguiente
drop_Nil: "drop n [] = []"
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

text {*
Ejemplo de análisis de casos:
Demostrar que el resultado de eliminar los n+1 primeros elementos de
xs es el mismo que eliminar los n primeros elementos del resto de xs.
*}

― ‹La demostración aplicativa es›
lemma "drop (n + 1) xs = drop n (tl xs)"
apply (cases xs)
(* 1. xs = [] ⟹ drop (n + 1) xs = drop n (tl xs)
2. ⋀a list. xs = a # list ⟹
drop (n + 1) xs = drop n (tl xs) *)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración automática es›
lemma "drop (n + 1) xs = drop n (tl xs)"
by (cases xs) auto

― ‹La demostración detallada es›
lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case Cons
then show ?thesis by simp
qed

section {* Inducción matemática *}

text {*
[Principio de inducción matemática]
Para demostrar una propiedad P para todos los números naturales basta
probar que el 0 tiene la propiedad P y que si n tiene la propiedad P,
entonces n+1 también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción matemática está formalizado en
el teorema nat.induct y puede verse con
thm nat.induct
*}

text {*
Ejemplo de demostración por inducción: Usaremos el principio de
inducción matemática para demostrar que
1 + 3 + ... + (2n-1) = n^2

Definición. [Suma de los primeros impares]
(suma_impares n) la suma de los n números impares. Por ejemplo,
suma_impares 3 = 9
*}

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

value "suma_impares 3"

text {*
Ejemplo de demostración por inducción matemática:
Demostrar que la suma de los n primeros números impares es n^2.
*}

― ‹La demostración aplicativa es›
lemma "suma_impares n = n * n"
apply (induct n)
(* 1. suma_impares 0 = 0 * 0
2. ⋀n. suma_impares n = n * n ⟹
suma_impares (Suc n) = Suc n * Suc n*)
apply simp_all
(* No subgoals! *)
done

― ‹La demostración automática es›
lemma "suma_impares n = n * n"
by (induct n) simp_all

― ‹Demostración del lema anterior por inducción y razonamiento
ecuacional›
lemma "suma_impares n = n * n"
proof (induct n)
show "suma_impares 0 = 0 * 0" by simp
next
fix n assume HI: "suma_impares n = n * n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n" using HI by simp
also have "… = n * n + 2 * n + 1" by simp
finally show "suma_impares (Suc n) = (Suc n) * (Suc n)" by simp
qed

― ‹Demostración del lema anterior con patrones y razonamiento
ecuacional›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume HI: "?P n"
have "suma_impares (Suc n) = (2 * (Suc n) - 1) + suma_impares n"
by simp
also have "… = (2 * (Suc n) - 1) + n * n" using HI by simp
also have "… = n * n + 2 * n + 1" by simp
finally show "?P (Suc n)" by simp
qed

text {*
Comentario sobre la demostración anterior:
· Con la expresión
"suma_impares n = n * n" (is "?P n")
se abrevia "suma_impares n = n * n" como "?P n". Por tanto,
"?P 0" es una abreviatura de "suma_impares 0 = 0 * 0"
"?P (Suc n)" es una abreviatura de "suma_impares (Suc n) =
(Suc n) * (Suc n)"
· En general, cualquier fórmula seguida de (is patrón) equipara el
patrón con la fórmula.
*}

― ‹La demostración usando patrones es›
lemma "suma_impares n = n * n" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n
assume "?P n"
then show "?P (Suc n)" by simp
qed

text {*
Ejemplo de definición con existenciales.
Un número natural n es par si existe un natural m tal que n=m+m.
*}

definition par :: "nat ⇒ bool" where
"par n ≡ ∃m. n=m+m"

text {*
Ejemplo de inducción y existenciales:
Demostrar que para todo número natural n, se verifica que n*(n+1) par.
*}

― ‹Demostración aplicativa›
lemma
shows "par (n*(n+1))"
apply (induct n)
(* par (0 * (0 + 1))
⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. par (n * (n + 1)) ⟹ par (Suc n * (Suc n + 1)) *)
apply (simp add: par_def)
(* ⋀n. ∃m. n + n * n = m + m ⟹
∃m. Suc (Suc (n + (n + (n + n * n)))) = m + m *)
apply (erule exE)
(* ⋀n m. n + n * n = m + m ⟹
∃m. Suc (Suc (n + (n + (n + n * n)))) = m + m*)
apply (rule_tac x="m+n+1" in exI)
(* ⋀n m. n + n * n = m + m ⟹
Suc (Suc (n + (n + (n + n * n)))) =
m + n + 1 + (m + n + 1)*)
apply simp
(* *)
done

― ‹Demostración declarativa›
lemma
fixes n :: "nat"
shows "par (n*(n+1))"
proof (induct n)
show "par (0*(0+1))" by (simp add: par_def)
next
fix n
assume "par (n*(n+1))"
then have "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" ..
then have "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
then have "∃m. (Suc n)*((Suc n)+1) = m+m" ..
then show "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

text {*
Comentarios sobre la demostración anterior:
· (fixes n :: "nat") es una abreviatura de "sea n un número natural".
*}

text {*
En Isabelle puede demostrarse de manera más simple un lema equivalente
usando en lugar de la función "par" la función "even" definida en la
teoría Parity por
even x ⟷ x mod 2 = 0"
*}

lemma
fixes n :: "nat"
shows "even (n*(n+1))"
by auto

text {*
Comentarios sobre la demostración anterior:
· Para poder usar la función "even" de la librería Parity es necesario
importar dicha librería. Por ello, antes del inicio de la teoría
aparece
imports Main Parity
*}

text {*
Para completar la demostración basta demostrar la equivalencia de las
funciones "par" y "even".
*}

lemma
fixes n :: "nat"
shows "par n = even n"
proof -
have "par n = (∃m. n = m+m)" by (simp add:par_def)
then show "par n = even n" by presburger
qed

text {*
Comentarios sobre la demostración anterior:
· "by presburger" indica que se use como método de demostración el
algoritmo de decisión de la aritmética de Presburger.
*}

section {* Inducción estructural *}

text {*
Inducción estructural:
· En Isabelle puede hacerse inducción estructural sobre cualquier tipo
recursivo.
· La inducción matemática es la inducción estructural sobre el tipo de
los naturales.
· El esquema de inducción estructural sobre listas es
· list.induct: ⟦P []; ⋀x ys. P ys ⟹ P (x # ys)⟧ ⟹ P zs
· Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a una
lista que tiene la propiedad se obtiene una lista que también tiene la
propiedad.
· En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct que puede verse con
thm list.induct
*}

text {*
Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"
*}

text {*
Lema. [Ejemplo de inducción sobre listas]
Demostrar que la concatenación de listas es asociativa.
*}

― ‹La demostración estructurada es›
lemma conc_asociativa: "xs @ (ys @ zs) = (xs @ ys) @ zs"
proof (induct xs)
show "[] @ (ys @ zs) = ([] @ ys) @ zs"
proof -
have "[] @ (ys @ zs) = ys @ zs" by simp
also have "… = ([] @ ys) @ zs" by simp
finally show ?thesis .
qed
next
fix x xs
assume HI: "xs @ (ys @ zs) = (xs @ ys) @ zs"
show "(x#xs) @ (ys @ zs) = ((x#xs) @ ys) @ zs"
proof -
have "(x#xs) @ (ys @ zs) = x#(xs @ (ys @ zs))" by simp
also have "… = x#((xs @ ys) @ zs)" using HI by simp
also have "… = (x#(xs @ ys)) @ zs" by simp
also have "… = ((x#xs) @ ys) @ zs" by simp
finally show ?thesis .
qed
qed

― ‹La demostración automática es›
lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) auto

section {* Heurísticas para la inducción *}

text {*
Definición. [Definición recursiva de inversa]
(inversa xs) la inversa de la lista xs. Por ejemplo,
inversa [a,b,c] = [c,b,a]
*}

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

value "inversa [a,b,c]"

text {*
Definición. [Definición de inversa con acumuladores]
(inversaAc xs) es la inversa de la lista xs calculada con
acumuladores. Por ejemplo,
inversaAc [a,b,c] = [c,b,a]
inversaAcAux [a,b,c] [] = [c,b,a]
*}

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

definition inversaAc :: "'a list ⇒ 'a list" where
"inversaAc xs ≡ inversaAcAux xs []"

value "inversaAcAux [a,b,c] []"
value "inversaAc [a,b,c]"

text {*
Lema. [Ejemplo de equivalencia entre las definiciones]
La inversa de [a,b,c] es lo mismo calculada con la primera definición
que con la segunda.
*}

lemma "inversaAc [a,b,c] = inversa [a,b,c]"
by (simp add: inversaAc_def)

text {*
Nota. [Ejemplo fallido de demostración por inducción]
El siguiente intento de demostrar que para cualquier lista xs, se
tiene que "inversaAc xs = inversa xs" falla.
*}

lemma "inversaAc xs = inversa xs"
proof (induct xs)
show "inversaAc [] = inversa []" by (simp add: inversaAc_def)
next
fix a xs assume HI: "inversaAc xs = inversa xs"
have "inversaAc (a#xs) = inversaAcAux (a#xs) []"
by (simp add: inversaAc_def)
also have "… = inversaAcAux xs [a]" by simp
also have "… = inversa (a#xs)"
(* Problema: la hipótesis de inducción no es aplicable. *)
oops

text {*
Nota. [Heurística de generalización]
Cuando se use demostración estructural, cuantificar universalmente las
variables libres (o, equivalentemente, considerar las variables libres
como variables arbitrarias).

Lema. [Lema con generalización]
Para toda lista ys se tiene
inversaAcAux xs ys = (inversa xs) @ ys
*}

― ‹La demostración estructurada es›
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs)@ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = (inversa [])@ys" by simp
next
fix a xs
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)" by simp
also have "… = inversa xs@(a#ys)" using HI by simp
also have "… = inversa (a#xs)@ys" using [[simp_trace]] by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys" by simp
qed
qed

― ‹La demostración automática es›
lemma inversaAcAux_es_inversa_1:
"inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) auto

text {*
Corolario. Para cualquier lista xs, se tiene que
inversaAc xs = inversa xs
*}

corollary "inversaAc xs = inversa xs"
using [[simp_trace]]
by (simp add: inversaAcAux_es_inversa inversaAc_def)

text {*
Nota. En el paso "inversa xs@(a#ys) = inversa (a#xs)@ys" se usan
lemas de la teoría List. Se puede observar, insertano
using [[simp_trace]]
entre la igualdad y by simp, que los lemas usados son
· List.append_simps_1: []@ys = ys
· List.append_simps_2: (x#xs)@ys = x#(xs@ys)
· List.append_assoc: (xs @ ys) @ zs = xs @ (ys @ zs)
Las dos primeras son las ecuaciones de la definición de append.

En la siguiente demostración se detallan los lemas utilizados.
*}

lemma "(inversa xs)@(a#ys) = (inversa (a#xs))@ys"
proof -
have "(inversa xs)@(a#ys) = (inversa xs)@(a#([]@ys))"
by (simp only: append.simps(1))
also have "… = (inversa xs)@([a]@ys)" by (simp only: append.simps(2))
also have "… = ((inversa xs)@[a])@ys" by (simp only: append_assoc)
also have "… = (inversa (a#xs))@ys" by (simp only: inversa.simps(2))
finally show ?thesis .
qed

section {* Recursión general. La función de Ackermann *}

text {*
El objetivo de esta sección es mostrar el uso de las definiciones
recursivas generales y sus esquemas de inducción. Como ejemplo se usa la
función de Ackermann (se puede consultar información sobre dicha función en
http://en.wikipedia.org/wiki/Ackermann_function).

Definición. La función de Ackermann se define por
A(m,n) = n+1, si m=0,
A(m-1,1), si m>0 y n=0,
A(m-1,A(m,n-1)), si m>0 y n>0
para todo los números naturales.

La función de Ackermann es recursiva, pero no es primitiva recursiva.
*}

fun ack :: "nat ⇒ nat ⇒ nat" where
"ack 0 n = n+1"
| "ack (Suc m) 0 = ack m 1"
| "ack (Suc m) (Suc n) = ack m (ack (Suc m) n)"

― ‹Ejemplo de evaluación›
value "ack 2 3" (* devuelve 9 *)

text {*
Esquema de inducción correspondiente a una función:
· Al definir una función recursiva general se genera una regla de
inducción. En la definición anterior, la regla generada es
ack.induct:
⟦⋀n. P 0 n;
⋀m. P m 1 ⟹ P (Suc m) 0;
⋀m n. ⟦P (Suc m) n; P m (ack (Suc m) n)⟧ ⟹ P (Suc m) (Suc n)⟧
⟹ P a b
*}

text {*
Ejemplo de demostración por la inducción correspondiente a una función:
Demostrar que para todos m y n, A(m,n) > n.
*}

― ‹La demostración detallada es›
lemma "ack m n > n"
proof (induct m n rule: ack.induct)
fix n
show "ack 0 n > n" by simp
next
fix m
assume "ack m 1 > 1"
then show "ack (Suc m) 0 > 0" by simp
next
fix m n
assume "n < ack (Suc m) n" and
"ack (Suc m) n < ack m (ack (Suc m) n)"
then show "Suc n < ack (Suc m) (Suc n)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· (induct m n rule: ack.induct) indica que el método de demostración
es el esquema de recursión correspondiente a la definición de
(ack m n).
· Se generan 3 casos:
1. ⋀n. n < ack 0 n
2. ⋀m. 1 < ack m 1 ⟹ 0 < ack (Suc m) 0
3. ⋀m n. ⟦n < ack (Suc m) n;
ack (Suc m) n < ack m (ack (Suc m) n)⟧
⟹ Suc n < ack (Suc m) (Suc n)
*}

― ‹La demostración automática es›
lemma "ack m n > n"
by (induct m n rule: ack.induct) auto

end
</source>

Razonamiento sobre programas en Isabelle/HOL

2019-05-01T14:13:14Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 6: Razonamiento sobre programas *}

theory T6_Razonamiento_sobre_programas
imports Main
begin

text {*
En este tema se demuestra con Isabelle las propiedades de los
programas funcionales de tema 6 http://bit.ly/2Za6YWY

Para cada propiedades se presentan distintos tipos de demostraciones:
automáticas, aplicativas y declarativas. *}

declare [[names_short]]

section {* Razonamiento ecuacional *}

text {* ----------------------------------------------------------------
Ejemplo 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 [a,c,d] = 3
------------------------------------------------------------------- *}

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

value "longitud [a,c,d] = 3"

text {* ---------------------------------------------------------------
Ejemplo 2. Demostrar que
longitud [a,c,d] = 3
------------------------------------------------------------------- *}

lemma "longitud [a,c,d] = 3"
apply simp
done

lemma "longitud [a,c,d] = 3"
by simp

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

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

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

text {*
La definición de la función intercambia genera una regla de
simplificación
· intercambia.simps: intercambia (x,y) = (y,x)

Se puede ver con
· thm intercambia.simps
*}

thm intercambia.simps
(* da intercambia (?x, ?y) = (?y, ?x) *)

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

(* Demostración automática *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by auto

(* Demostración automática 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

(* Demostración automática 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by (simp only: intercambia.simps)

(* Demostración aplicativa *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
apply (simp only: intercambia.simps)
done

(* Demostración declarativa 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)" by simp
also have "... = (x,y)" by simp
finally show "intercambia (intercambia (x,y)) = (x,y)" by simp
qed

(* Demostración declarativa 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by (simp only: intercambia.simps)
also have "... = (x,y)"
by (simp only: intercambia.simps)
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

text {*
Notas sobre el lenguaje: En la demostración anterior se ha usado
· "proof" para iniciar la prueba,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "by (simp only: intercambia.simps)" para indicar que sólo se usa
como regla de escritura la correspondiente a la definición de
intercambia,
· "also" para encadenar pasos ecuacionales,
· "..." para representar la derecha de la igualdad anterior en un
razonamiento ecuacional,
· "finally" para indicar el último pasa de un razonamiento ecuacional,
· "show" para establecer la conclusión.
· "by simp" para indicar el método de demostración por simplificación y
· "qed" para terminar la pruebas,
*}

text {*
Nota: La diferencia entre las dos demostraciones es que en los dos
primeros pasos no se explicita la regla de simplificación.
*}

text {* ---------------------------------------------------------------
Ejemplo 5. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [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 {* ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

(* La demostración automática es *)
lemma "inversa [x] = [x]"
by simp

(* La demostración aplicativa es *)
lemma "inversa [x] = [x]"
apply simp
done

text {*
En la demostración anterior se usaron las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
Vamos a explicitar su aplicación.
*}

(* La demostración aplicativa detallada es *)
lemma "inversa [x] = [x]"
apply (simp only: inversa.simps(2)) (* inversa [] @ [x] = [x] *)
apply (simp only: inversa.simps(1)) (* [] @ [x] = [x] *)
apply (simp only: append_Nil) (* No subgoals! *)
done

(* La demostración declarativa es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by (simp only: inversa.simps(2))
also have "... = [] @ [x]" by (simp only: inversa.simps(1))
also have "... = [x]" by (simp only: append_Nil)
finally show "inversa [x] = [x]" by simp
qed

(* La demostración declarativa simplificada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by simp
also have "... = [] @ [x]" by simp
also have "... = [x]" by simp
finally show "inversa [x] = [x]" by simp
qed

section {* Razonamiento por inducción sobre los naturales *}

text {*
[Principio de inducción sobre los naturales] Para demostrar una
propiedad P para todos los números naturales basta probar que el 0
tiene la propiedad P y que si n tiene la propiedad P, entonces n+1
también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción sobre los naturales está
formalizado en el teorema nat.induct y puede verse con
thm nat.induct
*}

text {* ---------------------------------------------------------------
Ejemplo 7. 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 {* ---------------------------------------------------------------
Ejemplo 8. (p. 18) Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* 1. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* No subgoals *)
done

(* La demostración aplicativa con simp_all es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp_all (* No subgoals *)
done

(* La demostración automática es *)
lemma "longitud (repite n x) = n"
by (induct n) simp_all

(* La demostración declarativa es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0" by simp
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by simp
also have "... = 1 + longitud (repite n x)" by simp
also have "... = 1 + n" using HI by simp
finally show "longitud (repite (Suc n) x) = Suc n" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· A la derecha de proof se indica el método de la demostración.
· (induct n) indica que la demostración se hará por inducción en n.
· Se generan dos subobjetivos correspondientes a la base y el paso de
inducción:
1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n
donde ⋀n se lee "para todo n".
· "next" indica el siguiente subobjetivo.
· "fix n" indica "sea n un número natural cualquiera"
· assume HI: "longitud (repite n x) = n" indica «supongamos que
"longitud (repite n x) = n" y sea HI la etiqueta de este supuesto».
· "using HI" usando la propiedad etiquetada con HI.
*}

section {* Razonamiento por inducción sobre listas *}

text {*
Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a
una lista que tiene la propiedad se obtiene otra lista que también
tiene la propiedad.

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct
⟦P [];
⋀x xs. P xs ⟹ P (x#xs)⟧
⟹ P xs
*}

text {* ---------------------------------------------------------------
Ejemplo 9. 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 {* ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs) (* 1. conc [] (conc ys zs) = conc (conc [] ys) zs
2. ⋀a xs.
conc xs (conc ys zs) =
conc (conc xs ys) zs ⟹
conc (a # xs) (conc ys zs) =
conc (conc (a # xs) ys) zs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs" by simp
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))" by simp
also have "... = x # (conc (conc xs ys) zs)" using HI by simp
also have "... = conc (conc (x # xs) ys) zs" by simp
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by simp
qed

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

lemma "conc xs ys = conc ys xs"
quickcheck
oops

text {* Encuentra el contraejemplo,
xs = [a2]
ys = [a1] *}

text {* ---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs [] = xs"
apply (induct xs) (* 1. conc [] [] = []
2. ⋀a xs.
conc xs [] = xs ⟹
conc (a # xs) [] = a # xs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs [] = xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x xs
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])" by simp
also have "... = x # xs" using HI by simp
finally show "conc (x # xs) [] = x # xs" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs) (* 1. longitud (conc [] ys) =
longitud [] + longitud ys
2. ⋀a xs.
longitud (conc xs ys) =
longitud xs + longitud ys ⟹
longitud (conc (a # xs) ys) =
longitud (a # xs) + longitud ys *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys" by simp
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by simp
also have "... = 1 + longitud (conc xs ys)" by simp
also have "... = 1 + longitud xs + longitud ys" using HI by simp
also have "... = longitud (x # xs) + longitud ys" by simp
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys" by simp
qed

section {* Inducción correspondiente a la definición recursiva *}

text {* ---------------------------------------------------------------
Ejemplo 14. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [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 {* ---------------------------------------------------------------
Ejemplo 15. 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 {*
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". *}

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

(* La demostración aplicativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
(* 1. ⋀n. conc (coge n []) (elimina n []) = []
2. ⋀v va. conc (coge 0 (v # va)) (elimina 0 (v # va)) =
v # va
3. ⋀n x xs. conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x # xs))
(elimina (Suc n) (x # xs)) =
x # xs *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) simp_all

(* La demostración declarativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []" by simp
next
fix x xs
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs" by simp
next
fix n x xs
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)" by simp
also have "... = x#(conc (coge n xs) (elimina n xs))" by simp
also have "... = x#xs" using HI by simp
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by simp
qed

text {*
Comentario sobre la demostración anterior:
· (induct rule: coge.induct) indica que el método de demostración es
por el esquema de inducción correspondiente a la definición de la
función coge.
· Se generan 3 subobjetivos:
· 1. ⋀n. conc (coge n []) (elimina n []) = []
· 2. ⋀x xs. conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs
· 3. ⋀n x xs.
conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) = x#xs
*}

section {* Razonamiento por casos *}

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

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

value "esVacia [] = True"
value "esVacia [a] = False"

text {* ---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
(* 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
2. ⋀a list. xs = a # list ⟹
esVacia xs = esVacia (conc xs xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) simp_all

(* La demostración declarativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "(cases xs)" es el método de demostración por casos según xs.
· Se generan dos subobjetivos correspondientes a los dos
constructores de listas:
· 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
· 2. ⋀y ys. xs = y#ys ⟹ esVacia xs = esVacia (conc xs xs)
· "then" indica "usando la propiedad anterior"
*}

(* La demostración declarativa simplificada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
case Cons
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de "assume xs = []"
· "case Cons" es una abreviatura de "fix y ys assume xs = y#ys"
· "thus" es una abreviatura de "then show".
*}

(* La demostración con el patrón sugerido es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case (Cons x xs)
then show ?thesis by simp
qed

section {* Heurística de generalización *}

text {*
Heurística de generalización: Cuando se use demostración estructural,
cuantificar universalmente las variables libres (o, equivalentemente,
considerar las variables libres como variables arbitrarias). *}

text {* ---------------------------------------------------------------
Ejemplo 19. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [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 {* ---------------------------------------------------------------
Ejemplo 20. (p. 44) Demostrar que
inversaAcAux xs ys = (inversa xs) @ ys
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
(* 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
2. ⋀a xs ys.
(⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) simp_all

(* La demostración declarativa es *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = inversa [] @ ys" by simp
next
fix a xs
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)" by simp
also have "… = inversa xs@(a#ys)" using HI by simp
also have "… = inversa (a#xs)@ys" by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys" by simp
qed
qed

text {*
Comentarios sobre la demostración anterior:
· "(induct xs arbitrary: ys)" es el método de demostración por
inducción sobre xs usando ys como variable arbitraria.
· Se generan dos subobjetivos:
· 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
· 2. ⋀a xs ys. (⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys
· Dentro de una demostración se pueden incluir otras demostraciones.
· Para demostrar la propiedad universal "⋀ys. P(ys)" se elige una
lista arbitraria (con "fix ys") y se demuestra "P(ys)".
*}

text {* ---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
corollary "inversaAc xs = inversa xs"
apply (simp add: inversaAcAux_es_inversa)
done

(* La demostración automática es *)
corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa)

text {*
Comentario de la demostración anterior:
· "(simp add: inversaAcAux_es_inversa)" es el método de demostración
por simplificación usando como regla de simplificación la propiedad
inversaAcAux_es_inversa.
*}

section {* Demostración por inducción para funciones de orden superior *}

text {* ---------------------------------------------------------------
Ejemplo 22. 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 {* ---------------------------------------------------------------
Ejemplo 23. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3::nat,2,5] = [6,4,10]
map (( * ) 2) [3::nat,2,5] = [6,4,10]
map ((+) 2) [3::nat,2,5] = [5,4,7]
------------------------------------------------------------------ *}

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]"
value "map (( * ) 2) [3::nat,2,5] = [6,4,10]"
value "map ((+) 2) [3::nat,2,5] = [5,4,7]"

text {* ---------------------------------------------------------------
Ejemplo 24. (p. 45) Demostrar que
sum (map (( * ) 2) xs) = 2 * (sum xs)
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
apply (induct xs)
(* 1. sum (map (( * ) 2) []) = 2 * sum []
2. ⋀a xs. sum (map (( * ) 2) xs) = 2 * sum xs ⟹
sum (map (( * ) 2) (a # xs)) = 2 * sum (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "sum (map (( * ) 2) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map (( * ) 2) []) = 2 * (sum [])" by simp
next
fix a xs
assume HI: "sum (map (( * ) 2) xs) = 2 * (sum xs)"
have "sum (map (( * ) 2) (a#xs)) = sum ((2*a)#(map (( * ) 2) xs))"
by simp
also have "... = 2*a + sum (map (( * ) 2) xs)" by simp
also have "... = 2*a + 2*(sum xs)" using HI by simp
also have "... = 2*(a + sum xs)" by simp
also have "... = 2*(sum (a#xs))" by simp
finally show "sum (map (( * ) 2) (a#xs)) = 2*(sum (a#xs))" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
(* 1. longitud (map f []) = longitud []
2. ⋀a xs. longitud (map f xs) = longitud xs ⟹
longitud (map f (a # xs)) = longitud (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) simp_all

(* La demostración declarativa es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []" by simp
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))" by simp
also have "... = 1 + longitud (map f xs)" by simp
also have "... = 1 + longitud xs" using HI by simp
also have "... = longitud (a#xs)" by simp
finally show "longitud (map f (a#xs)) = longitud (a#xs)" by simp
qed

section {* Referencias *}

text {*
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms".
· S. Thompson. "Haskell: the Craft of Functional Programming, 3rd
Edition. Cap. 8 "Reasoning about programms".
· L. Paulson. "ML for the Working Programmer, 2nd Edition". Cap. 6.
"Reasoning about functional programs".
*}

end
</source>

Razonamiento sobre programas en Isabelle/HOL

2019-05-01T14:12:30Z

Jalonso:

<source lang="isabelle">
chapter {* Tema 6: Razonamiento sobre programas *}

theory T6_Razonamiento_sobre_programas
imports Main
begin

text {*
En este tema se demuestra con Isabelle las propiedades de los
programas funcionales de tema 6 http://bit.ly/2Za6YWY

Para cada propiedades se presentan distintos tipos de demostraciones:
automáticas, aplicativas y estructuradas. *}

declare [[names_short]]

section {* Razonamiento ecuacional *}

text {* ----------------------------------------------------------------
Ejemplo 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 [a,c,d] = 3
------------------------------------------------------------------- *}

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

value "longitud [a,c,d] = 3"

text {* ---------------------------------------------------------------
Ejemplo 2. Demostrar que
longitud [a,c,d] = 3
------------------------------------------------------------------- *}

lemma "longitud [a,c,d] = 3"
apply simp
done

lemma "longitud [a,c,d] = 3"
by simp

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

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

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

text {*
La definición de la función intercambia genera una regla de
simplificación
· intercambia.simps: intercambia (x,y) = (y,x)

Se puede ver con
· thm intercambia.simps
*}

thm intercambia.simps
(* da intercambia (?x, ?y) = (?y, ?x) *)

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

(* Demostración automática *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by auto

(* Demostración automática 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

(* Demostración automática 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
by (simp only: intercambia.simps)

(* Demostración aplicativa *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
apply (simp only: intercambia.simps)
done

(* Demostración declarativa 1 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)" by simp
also have "... = (x,y)" by simp
finally show "intercambia (intercambia (x,y)) = (x,y)" by simp
qed

(* Demostración declarativa 2 *)
lemma "intercambia (intercambia (x,y)) = (x,y)"
proof -
have "intercambia (intercambia (x,y)) = intercambia (y,x)"
by (simp only: intercambia.simps)
also have "... = (x,y)"
by (simp only: intercambia.simps)
finally show "intercambia (intercambia (x,y)) = (x,y)"
by simp
qed

text {*
Notas sobre el lenguaje: En la demostración anterior se ha usado
· "proof" para iniciar la prueba,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "by (simp only: intercambia.simps)" para indicar que sólo se usa
como regla de escritura la correspondiente a la definición de
intercambia,
· "also" para encadenar pasos ecuacionales,
· "..." para representar la derecha de la igualdad anterior en un
razonamiento ecuacional,
· "finally" para indicar el último pasa de un razonamiento ecuacional,
· "show" para establecer la conclusión.
· "by simp" para indicar el método de demostración por simplificación y
· "qed" para terminar la pruebas,
*}

text {*
Nota: La diferencia entre las dos demostraciones es que en los dos
primeros pasos no se explicita la regla de simplificación.
*}

text {* ---------------------------------------------------------------
Ejemplo 5. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [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 {* ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

(* La demostración automática es *)
lemma "inversa [x] = [x]"
by simp

(* La demostración aplicativa es *)
lemma "inversa [x] = [x]"
apply simp
done

text {*
En la demostración anterior se usaron las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
Vamos a explicitar su aplicación.
*}

(* La demostración aplicativa detallada es *)
lemma "inversa [x] = [x]"
apply (simp only: inversa.simps(2)) (* inversa [] @ [x] = [x] *)
apply (simp only: inversa.simps(1)) (* [] @ [x] = [x] *)
apply (simp only: append_Nil) (* No subgoals! *)
done

(* La demostración declarativa es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by (simp only: inversa.simps(2))
also have "... = [] @ [x]" by (simp only: inversa.simps(1))
also have "... = [x]" by (simp only: append_Nil)
finally show "inversa [x] = [x]" by simp
qed

(* La demostración declarativa simplificada es *)
lemma "inversa [x] = [x]"
proof -
have "inversa [x] = inversa (x#[])" by simp
also have "... = (inversa []) @ [x]" by simp
also have "... = [] @ [x]" by simp
also have "... = [x]" by simp
finally show "inversa [x] = [x]" by simp
qed

section {* Razonamiento por inducción sobre los naturales *}

text {*
[Principio de inducción sobre los naturales] Para demostrar una
propiedad P para todos los números naturales basta probar que el 0
tiene la propiedad P y que si n tiene la propiedad P, entonces n+1
también la tiene.
⟦P 0; ⋀n. P n ⟹ P (Suc n)⟧ ⟹ P m

En Isabelle el principio de inducción sobre los naturales está
formalizado en el teorema nat.induct y puede verse con
thm nat.induct
*}

text {* ---------------------------------------------------------------
Ejemplo 7. 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 {* ---------------------------------------------------------------
Ejemplo 8. (p. 18) Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* 1. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp (* No subgoals *)
done

(* La demostración aplicativa con simp_all es *)
lemma "longitud (repite n x) = n"
apply (induct n) (* 1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n *)
apply simp_all (* No subgoals *)
done

(* La demostración automática es *)
lemma "longitud (repite n x) = n"
by (induct n) simp_all

(* La demostración estructurada es *)
lemma "longitud (repite n x) = n"
proof (induct n)
show "longitud (repite 0 x) = 0" by simp
next
fix n
assume HI: "longitud (repite n x) = n"
have "longitud (repite (Suc n) x) = longitud (x # (repite n x))"
by simp
also have "... = 1 + longitud (repite n x)" by simp
also have "... = 1 + n" using HI by simp
finally show "longitud (repite (Suc n) x) = Suc n" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· A la derecha de proof se indica el método de la demostración.
· (induct n) indica que la demostración se hará por inducción en n.
· Se generan dos subobjetivos correspondientes a la base y el paso de
inducción:
1. longitud (repite 0 x) = 0
2. ⋀n. longitud (repite n x) = n ⟹
longitud (repite (Suc n) x) = Suc n
donde ⋀n se lee "para todo n".
· "next" indica el siguiente subobjetivo.
· "fix n" indica "sea n un número natural cualquiera"
· assume HI: "longitud (repite n x) = n" indica «supongamos que
"longitud (repite n x) = n" y sea HI la etiqueta de este supuesto».
· "using HI" usando la propiedad etiquetada con HI.
*}

section {* Razonamiento por inducción sobre listas *}

text {*
Para demostrar una propiedad para todas las listas basta demostrar
que la lista vacía tiene la propiedad y que al añadir un elemento a
una lista que tiene la propiedad se obtiene otra lista que también
tiene la propiedad.

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct
⟦P [];
⋀x xs. P xs ⟹ P (x#xs)⟧
⟹ P xs
*}

text {* ---------------------------------------------------------------
Ejemplo 9. 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 {* ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs) (* 1. conc [] (conc ys zs) = conc (conc [] ys) zs
2. ⋀a xs.
conc xs (conc ys zs) =
conc (conc xs ys) zs ⟹
conc (a # xs) (conc ys zs) =
conc (conc (a # xs) ys) zs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) simp_all

(* La demostración estructurada es *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
proof (induct xs)
show "conc [] (conc ys zs) = conc (conc [] ys) zs" by simp
next
fix x xs
assume HI: "conc xs (conc ys zs) = conc (conc xs ys) zs"
have "conc (x # xs) (conc ys zs) = x # (conc xs (conc ys zs))" by simp
also have "... = x # (conc (conc xs ys) zs)" using HI by simp
also have "... = conc (conc (x # xs) ys) zs" by simp
finally show "conc (x # xs) (conc ys zs) = conc (conc (x # xs) ys) zs"
by simp
qed

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

lemma "conc xs ys = conc ys xs"
quickcheck
oops

text {* Encuentra el contraejemplo,
xs = [a2]
ys = [a1] *}

text {* ---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "conc xs [] = xs"
apply (induct xs) (* 1. conc [] [] = []
2. ⋀a xs.
conc xs [] = xs ⟹
conc (a # xs) [] = a # xs *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc xs [] = xs"
by (induct xs) simp_all

(* La demostración estructurada es *)
lemma "conc xs [] = xs"
proof (induct xs)
show "conc [] [] = []" by simp
next
fix x xs
assume HI: "conc xs [] = xs"
have "conc (x # xs) [] = x # (conc xs [])" by simp
also have "... = x # xs" using HI by simp
finally show "conc (x # xs) [] = x # xs" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs) (* 1. longitud (conc [] ys) =
longitud [] + longitud ys
2. ⋀a xs.
longitud (conc xs ys) =
longitud xs + longitud ys ⟹
longitud (conc (a # xs) ys) =
longitud (a # xs) + longitud ys *)
apply simp_all (* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) simp_all

(* La demostración estructurada es *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
proof (induct xs)
show "longitud (conc [] ys) = longitud [] + longitud ys" by simp
next
fix x xs
assume HI: "longitud (conc xs ys) = longitud xs + longitud ys"
have "longitud (conc (x # xs) ys) = longitud (x # (conc xs ys))"
by simp
also have "... = 1 + longitud (conc xs ys)" by simp
also have "... = 1 + longitud xs + longitud ys" using HI by simp
also have "... = longitud (x # xs) + longitud ys" by simp
finally show "longitud (conc (x # xs) ys) =
longitud (x # xs) + longitud ys" by simp
qed

section {* Inducción correspondiente a la definición recursiva *}

text {* ---------------------------------------------------------------
Ejemplo 14. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [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 {* ---------------------------------------------------------------
Ejemplo 15. 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 {*
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". *}

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

(* La demostración aplicativa es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
(* 1. ⋀n. conc (coge n []) (elimina n []) = []
2. ⋀v va. conc (coge 0 (v # va)) (elimina 0 (v # va)) =
v # va
3. ⋀n x xs. conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x # xs))
(elimina (Suc n) (x # xs)) =
x # xs *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) simp_all

(* La demostración estructurada es *)
lemma "conc (coge n xs) (elimina n xs) = xs"
proof (induct rule: coge.induct)
fix n
show "conc (coge n []) (elimina n []) = []" by simp
next
fix x xs
show "conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs" by simp
next
fix n x xs
assume HI: "conc (coge n xs) (elimina n xs) = xs"
have "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
conc (x#(coge n xs)) (elimina n xs)" by simp
also have "... = x#(conc (coge n xs) (elimina n xs))" by simp
also have "... = x#xs" using HI by simp
finally show "conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) =
x#xs"
by simp
qed

text {*
Comentario sobre la demostración anterior:
· (induct rule: coge.induct) indica que el método de demostración es
por el esquema de inducción correspondiente a la definición de la
función coge.
· Se generan 3 subobjetivos:
· 1. ⋀n. conc (coge n []) (elimina n []) = []
· 2. ⋀x xs. conc (coge 0 (x#xs)) (elimina 0 (x#xs)) = x#xs
· 3. ⋀n x xs.
conc (coge n xs) (elimina n xs) = xs ⟹
conc (coge (Suc n) (x#xs)) (elimina (Suc n) (x#xs)) = x#xs
*}

section {* Razonamiento por casos *}

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

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

value "esVacia [] = True"
value "esVacia [a] = False"

text {* ---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
(* 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
2. ⋀a list. xs = a # list ⟹
esVacia xs = esVacia (conc xs xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) simp_all

(* La demostración estructurada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
assume "xs = []"
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
fix y ys
assume "xs = y#ys"
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "(cases xs)" es el método de demostración por casos según xs.
· Se generan dos subobjetivos correspondientes a los dos
constructores de listas:
· 1. xs = [] ⟹ esVacia xs = esVacia (conc xs xs)
· 2. ⋀y ys. xs = y#ys ⟹ esVacia xs = esVacia (conc xs xs)
· "then" indica "usando la propiedad anterior"
*}

(* La demostración estructurada simplificada es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show "esVacia xs = esVacia (conc xs xs)" by simp
next
case Cons
then show "esVacia xs = esVacia (conc xs xs)" by simp
qed

text {*
Comentarios sobre la demostración anterior:
· "case Nil" es una abreviatura de "assume xs = []"
· "case Cons" es una abreviatura de "fix y ys assume xs = y#ys"
· "thus" es una abreviatura de "then show".
*}

(* La demostración con el patrón sugerido es *)
lemma "esVacia xs = esVacia (conc xs xs)"
proof (cases xs)
case Nil
then show ?thesis by simp
next
case (Cons x xs)
then show ?thesis by simp
qed

section {* Heurística de generalización *}

text {*
Heurística de generalización: Cuando se use demostración estructural,
cuantificar universalmente las variables libres (o, equivalentemente,
considerar las variables libres como variables arbitrarias). *}

text {* ---------------------------------------------------------------
Ejemplo 19. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [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 {* ---------------------------------------------------------------
Ejemplo 20. (p. 44) Demostrar que
inversaAcAux xs ys = (inversa xs) @ ys
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
(* 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
2. ⋀a xs ys.
(⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) simp_all

(* La demostración estructurada es *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs) @ ys"
proof (induct xs arbitrary: ys)
show "⋀ys. inversaAcAux [] ys = inversa [] @ ys" by simp
next
fix a xs
assume HI: "⋀ys. inversaAcAux xs ys = inversa xs@ys"
show "⋀ys. inversaAcAux (a#xs) ys = inversa (a#xs)@ys"
proof -
fix ys
have "inversaAcAux (a#xs) ys = inversaAcAux xs (a#ys)" by simp
also have "… = inversa xs@(a#ys)" using HI by simp
also have "… = inversa (a#xs)@ys" by simp
finally show "inversaAcAux (a#xs) ys = inversa (a#xs)@ys" by simp
qed
qed

text {*
Comentarios sobre la demostración anterior:
· "(induct xs arbitrary: ys)" es el método de demostración por
inducción sobre xs usando ys como variable arbitraria.
· Se generan dos subobjetivos:
· 1. ⋀ys. inversaAcAux [] ys = inversa [] @ ys
· 2. ⋀a xs ys. (⋀ys. inversaAcAux xs ys = inversa xs @ ys) ⟹
inversaAcAux (a # xs) ys = inversa (a # xs) @ ys
· Dentro de una demostración se pueden incluir otras demostraciones.
· Para demostrar la propiedad universal "⋀ys. P(ys)" se elige una
lista arbitraria (con "fix ys") y se demuestra "P(ys)".
*}

text {* ---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

(* La demostración aplicativa es *)
corollary "inversaAc xs = inversa xs"
apply (simp add: inversaAcAux_es_inversa)
done

(* La demostración automática es *)
corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa)

text {*
Comentario de la demostración anterior:
· "(simp add: inversaAcAux_es_inversa)" es el método de demostración
por simplificación usando como regla de simplificación la propiedad
inversaAcAux_es_inversa.
*}

section {* Demostración por inducción para funciones de orden superior *}

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

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]"

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

(* La demostración aplicativa es *)
lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
apply (induct xs)
(* 1. sum (map (( * ) 2) []) = 2 * sum []
2. ⋀a xs. sum (map (( * ) 2) xs) = 2 * sum xs ⟹
sum (map (( * ) 2) (a # xs)) = 2 * sum (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
by (induct xs) simp_all

(* La demostración estructurada es *)
lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
proof (induct xs)
show "sum (map (λx. 2*x) []) = 2 * (sum [])" by simp
next
fix a xs
assume HI: "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
have "sum (map (λx. 2*x) (a#xs)) = sum ((2*a)#(map (λx. 2*x) xs))"
by simp
also have "... = 2*a + sum (map (λx. 2*x) xs)" by simp
also have "... = 2*a + 2*(sum xs)" using HI by simp
also have "... = 2*(a + sum xs)" by simp
also have "... = 2*(sum (a#xs))" by simp
finally show "sum (map (λx. 2*x) (a#xs)) = 2*(sum (a#xs))" by simp
qed

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

(* La demostración aplicativa es *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
(* 1. longitud (map f []) = longitud []
2. ⋀a xs. longitud (map f xs) = longitud xs ⟹
longitud (map f (a # xs)) = longitud (a # xs) *)
apply simp_all
(* No subgoals! *)
done

(* La demostración automática es *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) simp_all

(* La demostración estructurada es *)
lemma "longitud (map f xs) = longitud xs"
proof (induct xs)
show "longitud (map f []) = longitud []" by simp
next
fix a xs
assume HI: "longitud (map f xs) = longitud xs"
have "longitud (map f (a#xs)) = longitud (f a # (map f xs))" by simp
also have "... = 1 + longitud (map f xs)" by simp
also have "... = 1 + longitud xs" using HI by simp
also have "... = longitud (a#xs)" by simp
finally show "longitud (map f (a#xs)) = longitud (a#xs)" by simp
qed

section {* Referencias *}

text {*
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms".
· S. Thompson. "Haskell: the Craft of Functional Programming, 3rd
Edition. Cap. 8 "Reasoning about programms".
· L. Paulson. "ML for the Working Programmer, 2nd Edition". Cap. 6.
"Reasoning about functional programs".
*}

end
</source>

Sol 7b

2019-04-21T09:26:59Z

Jalonso:

<source lang="isabelle">
theory R7b
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 y los métodos rule, erule, frule, drule y assumption.
· 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)

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

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

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

lemma ej1a: "∀x. P x ⟶ Q x ⟹ (∀x. P x) ⟶ (∀x. Q x)"
apply (rule impI) (* ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ ∀x. Q x*)
apply (rule allI) (* ⋀x. ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ Q x *)
apply (erule allE) (* ⋀x. ⟦∀x. P x; P (?x4 x) ⟶ Q (?x4 x)⟧ ⟹ Q x *)
apply (erule allE) (* ⋀x. ⟦P (?x4 x) ⟶ Q (?x4 x); P (?x6 x)⟧ ⟹ Q x *)
apply (erule mp) (* ⋀x. P (?x6 x) ⟹ P x *)
apply assumption (* *)
done

lemma ej1b: "∀x. P x ⟶ Q x ⟹ (∀x. P x) ⟶ (∀x. Q x)"
apply (rule impI) (* ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ ∀x. Q x *)
apply (rule allI) (* ⋀x. ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ Q x *)
apply (erule_tac x=x in allE) (* ⋀x. ⟦∀x. P x; P x ⟶ Q x⟧ ⟹ Q x *)
apply (erule_tac x=x in allE) (* ⋀x. ⟦P x ⟶ Q x; P x⟧ ⟹ Q x *)
apply (erule mp) (* ⋀x. P x ⟹ P x *)
apply assumption (* *)
done

lemma ej1c: "∀x. P x ⟶ Q x ⟹ (∀x. P x) ⟶ (∀x. Q x)"
apply (rule impI) (* ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ ∀x. Q x *)
apply (rule allI) (* ⋀x. ⟦∀x. P x ⟶ Q x; ∀x. P x⟧ ⟹ Q x *)
apply (erule_tac x=x in allE)+ (* ⋀x. ⟦P x ⟶ Q x; P x⟧ ⟹ Q x *)
apply (erule mp) (* ⋀x. P x ⟹ P x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
∃x. ¬(P x) ⊢ ¬(∀x. P x)
------------------------------------------------------------------ *}

lemma ej2: "∃x. ¬(P x) ⟹ ¬(∀x. P x)"
apply (rule notI) (* ⟦∃x. ¬ P x; ∀x. P x⟧ ⟹ False *)
apply (erule exE) (* ⋀x. ⟦∀x. P x; ¬ P x⟧ ⟹ False *)
apply (erule_tac x=x in allE) (* ⋀x. ⟦¬ P x; P x⟧ ⟹ False *)
apply (erule notE) (* ⋀x. P x ⟹ P x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
∀x. P x ⊢ ∀y. P y
------------------------------------------------------------------ *}

lemma ej3: "∀x. P x ⟹ ∀y. P y"
apply (rule allI) (* ⋀y. ∀x. P x ⟹ P y *)
apply (erule_tac x=y in allE) (* ⋀y. P y ⟹ P y*)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
∀x. P x ⟶ Q x ⊢ (∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))
------------------------------------------------------------------ *}

lemma ej4: "∀x. P x ⟶ Q x ⟹ (∀x. ¬(Q x)) ⟶ (∀x. ¬(P x))"
apply (rule impI) (* ⟦∀x. P x ⟶ Q x; ∀x. ¬ Q x⟧ ⟹ ∀x. ¬ P x *)
apply (rule allI) (* ⋀x. ⟦∀x. P x ⟶ Q x; ∀x. ¬ Q x⟧ ⟹ ¬ P x *)
apply (erule_tac x=x in allE)+
(* ⋀x. ⟦P x ⟶ Q x; ¬ Q x⟧ ⟹ ¬ P x *)
apply (rule notI) (* ⋀x. ⟦P x ⟶ Q x; ¬ Q x; P x⟧ ⟹ False *)
apply (erule impE) (* ⋀x. ⟦¬ Q x; P x⟧ ⟹ P x
⋀x. ⟦¬ Q x; P x; Q x⟧ ⟹ False *)
apply assumption (* ⋀x. ⟦¬ Q x; P x; Q x⟧ ⟹ False *)
apply (erule notE) (* ⋀x. ⟦P x; Q x⟧ ⟹ Q x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
∀x. P x ⟶ ¬(Q x) ⊢ ¬(∃x. P x ∧ Q x)
------------------------------------------------------------------ *}

lemma ej5: "∀x. P x ⟶ ¬(Q x) ⟹ ¬(∃x. P x ∧ Q x)"
apply (rule notI)
(* ⟦∀x. P x ⟶ ¬ Q x; ∃x. P x ∧ Q x⟧ ⟹ False *)
apply (erule exE)
(* ⋀x. ⟦∀x. P x ⟶ ¬ Q x; P x ∧ Q x⟧ ⟹ False *)
apply (frule conjunct1)
(* ⋀x. ⟦∀x. P x ⟶ ¬ Q x; P x ∧ Q x; P x⟧ ⟹ False*)
apply (erule_tac x=x in allE)
(* ⋀x. ⟦P x ∧ Q x; P x; P x ⟶ ¬ Q x⟧ ⟹ False *)
apply (erule impE)
(* ⋀x. ⟦P x ∧ Q x; P x⟧ ⟹ P x
⋀x. ⟦P x ∧ Q x; P x; ¬ Q x⟧ ⟹ False *)
apply assumption
(* ⋀x. ⟦P x ∧ Q x; P x; ¬ Q x⟧ ⟹ False *)
apply (erule notE)
(* ⋀x. ⟦P x ∧ Q x; P x⟧ ⟹ Q x *)
apply (erule conjunct2)
(* *)
done

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
∀x y. P x y ⊢ ∀u v. P u v
------------------------------------------------------------------ *}

lemma ej6a: "∀x y. P x y ⟹ ∀u v. P u v"
apply (rule allI) (* ⋀u. ∀x y. P x y ⟹ ∀v. P u v *)
apply (rule allI) (* ⋀u v. ∀x y. P x y ⟹ P u v *)
apply (erule_tac x=u in allE) (* ⋀u v. ∀y. P u y ⟹ P u v *)
apply (erule_tac x=v in allE) (* ⋀u v. P u v ⟹ P u v *)
apply assumption (* *)
done

lemma ej6b: "∀x y. P x y ⟹ ∀u v. P u v"
apply (rule allI)+ (* ⋀u v. ∀x y. P x y ⟹ P u v *)
apply (erule allE)+ (* ⋀u v. P (?x4 u v) (?y6 u v) ⟹ P u v *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
∃x y. P x y ⟹ ∃u v. P u v
------------------------------------------------------------------ *}

lemma ej7a: "∃x y. P x y ⟹ ∃u v. P u v"
apply (erule exE) (* ⋀x. ∃y. P x y ⟹ ∃u v. P u v *)
apply (erule exE) (* ⋀x y. P x y ⟹ ∃u v. P u v*)
apply (rule_tac x=x in exI) (* ⋀x y. P x y ⟹ ∃v. P x v *)
apply (rule_tac x=y in exI) (* ⋀x y. P x y ⟹ P x y *)
apply assumption (* *)
done

lemma ej7b: "∃x y. P x y ⟹ ∃u v. P u v"
apply (erule exE)+ (* ⋀x y. P x y ⟹ ∃u v. P u v *)
apply (rule exI)+ (* ⋀x y. P x y ⟹ P (?u4 x y) (?v6 x y) *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
∃x. ∀y. P x y ⊢ ∀y. ∃x. P x y
------------------------------------------------------------------ *}

lemma ej8a: "∃x. ∀y. P x y ⟹ ∀y. ∃x. P x y"
apply (rule allI) (* ⋀y. ∃x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule exE) (* ⋀y x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule_tac x=y in allE) (* ⋀y x. P x y ⟹ ∃x. P x y *)
apply (erule_tac x=x in exI) (* *)
done

lemma ej8b: "∃x. ∀y. P x y ⟹ ∀y. ∃x. P x y"
apply (rule allI) (* ⋀y. ∃x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule exE) (* ⋀y x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule allE) (* ⋀y x. P x (?y4 y x) ⟹ ∃x. P x y *)
apply (erule exI) (* *)
done

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

lemma ej9: "∃x. P a ⟶ Q x ⟹ P a ⟶ (∃x. Q x)"
apply (rule impI) (* ⟦∃x. P a ⟶ Q x; P a⟧ ⟹ ∃x. Q x *)
apply (erule exE) (* ⋀x. ⟦P a; P a ⟶ Q x⟧ ⟹ ∃x. Q x *)
apply (rule_tac x=x in exI) (* ⋀x. ⟦P a; P a ⟶ Q x⟧ ⟹ Q x *)
apply (erule impE) (* ⋀x. P a ⟹ P a
⋀x. ⟦P a; Q x⟧ ⟹ Q x *)
apply assumption+ (* *)
done

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

lemma ej10: "P a ⟶ (∃x. Q x) ⟹ ∃x. P a ⟶ Q x"
apply (case_tac "P a")
(* ⟦P a ⟶ (∃x. Q x); P a⟧ ⟹ ∃x. P a ⟶ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply (erule impE)
(* P a ⟹ P a
⟦P a; ∃x. Q x⟧ ⟹ ∃x. P a ⟶ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply assumption
(* ⟦P a; ∃x. Q x⟧ ⟹ ∃x. P a ⟶ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply (erule exE)
(* ⋀x. ⟦P a; Q x⟧ ⟹ ∃x. P a ⟶ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply (rule_tac x=x in exI)
(* ⋀x. ⟦P a; Q x⟧ ⟹ P a ⟶ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply (rule impI)
(* ⋀x. ⟦P a; Q x; P a⟧ ⟹ Q x
⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply assumption
(* ⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ ∃x. P a ⟶ Q x *)
apply (rule_tac x=x in exI)
(* ⟦P a ⟶ (∃x. Q x); ¬ P a⟧ ⟹ P a ⟶ Q x*)
apply (rule impI) (* ⟦P a ⟶ (∃x. Q x); ¬ P a; P a⟧ ⟹ Q x *)
apply (erule notE)
(* ⟦P a ⟶ (∃x. Q x); P a⟧ ⟹ P a *)
apply assumption (* *)
done

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

lemma ej11: "(∃x. P x) ⟶ Q a ⟹ ∀x. P x ⟶ Q a"
apply (rule allI) (* ⋀x. (∃x. P x) ⟶ Q a ⟹ P x ⟶ Q a *)
apply (rule impI) (* ⋀x. ⟦(∃x. P x) ⟶ Q a; P x⟧ ⟹ Q a *)
apply (erule mp) (* ⋀x. P x ⟹ ∃x. P x *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
∀x. P x ⟶ Q a ⊢ ∃ x. P x ⟶ Q a
------------------------------------------------------------------ *}

lemma ej12: "∀x. P x ⟶ Q a ⟹ ∃x. P x ⟶ Q a"
apply (erule allE) (* P ?x ⟶ Q a ⟹ ∃x. P x ⟶ Q a *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
(∀x. P x) ∨ (∀x. Q x) ⊢ ∀x. P x ∨ Q x
------------------------------------------------------------------ *}

lemma ej13: "(∀x. P x) ∨ (∀x. Q x) ⟹ ∀x. P x ∨ Q x"
apply (rule allI) (* ⋀x. (∀x. P x) ∨ (∀x. Q x) ⟹ P x ∨ Q x *)
apply (erule disjE) (* ⋀x. ∀x. P x ⟹ P x ∨ Q x
⋀x. ∀x. Q x ⟹ P x ∨ Q x *)
apply (erule allE) (* ⋀x. P (?x5 x) ⟹ P x ∨ Q x
⋀x. ∀x. Q x ⟹ P x ∨ Q x *)
apply (erule disjI1) (* ⋀x. ∀x. Q x ⟹ P x ∨ Q x *)
apply (erule allE) (* ⋀x. Q (?x8 x) ⟹ P x ∨ Q x *)
apply (erule disjI2) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
∃x. P x ∧ Q x ⊢ (∃x. P x) ∧ (∃x. Q x)
------------------------------------------------------------------ *}

lemma ej14: "∃x. P x ∧ Q x ⟹ (∃x. P x) ∧ (∃x. Q x)"
apply (erule exE) (* ⋀x. P x ∧ Q x ⟹ (∃x. P x) ∧ (∃x. Q x) *)
apply (rule conjI) (* ⋀x. P x ∧ Q x ⟹ ∃x. P x
⋀x. P x ∧ Q x ⟹ ∃x. Q x *)
apply (drule conjunct1) (* ⋀x. P x ⟹ ∃x. P x
⋀x. P x ∧ Q x ⟹ ∃x. Q x *)
apply (erule exI) (* ⋀x. P x ∧ Q x ⟹ ∃x. Q x *)
apply (drule conjunct2) (* ⋀x. Q x ⟹ ∃x. Q x *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
∀x y. P y ⟶ Q x ⊢ (∃y. P y) ⟶ (∀x. Q x)
------------------------------------------------------------------ *}

lemma ej15: "∀x y. P y ⟶ Q x ⟹ (∃y. P y) ⟶ (∀x. Q x)"
apply (rule impI) (* ⟦∀x y. P y ⟶ Q x; ∃y. P y⟧ ⟹ ∀x. Q x *)
apply (rule allI) (* ⋀x. ⟦∀x y. P y ⟶ Q x; ∃y. P y⟧ ⟹ Q x *)
apply (erule exE) (* ⋀x y. ⟦∀x y. P y ⟶ Q x; P y⟧ ⟹ Q x *)
apply (erule_tac x=x in allE)
(* ⋀x y. ⟦P y; ∀y. P y ⟶ Q x⟧ ⟹ Q x *)
apply (erule_tac x=y in allE)
(* ⋀x y. ⟦P y; P y ⟶ Q x⟧ ⟹ Q x *)
apply (erule mp) (* ⋀x y. P y ⟹ P y *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
¬(∀x. ¬(P x)) ⊢ ∃x. P x
------------------------------------------------------------------ *}

lemma ej16: "¬(∀x. ¬(P x)) ⟹ ∃x. P x"
apply (rule ccontr) (* ⟦¬ (∀x. ¬ P x); ∄x. P x⟧ ⟹ False *)
apply (erule notE) (* ∄x. P x ⟹ ∀x. ¬ P x *)
apply (rule allI) (* ⋀x. ∄x. P x ⟹ ¬ P x *)
apply (rule notI) (* ⋀x. ⟦∄x. P x; P x⟧ ⟹ False *)
apply (erule notE) (* ⋀x. P x ⟹ ∃x. P x *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
∀x. ¬(P x) ⊢ ¬(∃x. P x)
------------------------------------------------------------------ *}

lemma ej17: "∀x. ¬(P x) ⟹ ¬(∃x. P x)"
apply (rule notI) (* ⟦∀x. ¬ P x; ∃x. P x⟧ ⟹ False *)
apply (erule exE) (* ⋀x. ⟦∀x. ¬ P x; P x⟧ ⟹ False *)
apply (erule_tac x=x in allE) (* ⋀x. ⟦P x; ¬ P x⟧ ⟹ False *)
apply (erule notE) (* ⋀x. P x ⟹ P x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
∃x. P x ⊢ ¬(∀x. ¬(P x))
------------------------------------------------------------------ *}

lemma ej18: "∃x. P x ⟹ ¬(∀x. ¬(P x))"
apply (rule notI) (* ⟦∃x. P x; ∀x. ¬ P x⟧ ⟹ False *)
apply (erule exE) (* ⋀x. ⟦∀x. ¬ P x; P x⟧ ⟹ False *)
apply (erule allE) (* ⋀x. ⟦P x; ¬ P (?x4 x)⟧ ⟹ False *)
apply (erule notE) (* ⋀x. P x ⟹ P (?x4 x) *)
apply assumption (* *)
done

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

lemma ej19: "P a ⟶ (∀x. Q x) ⟹ ∀x. P a ⟶ Q x"
apply (rule allI) (* ⋀x. P a ⟶ (∀x. Q x) ⟹ P a ⟶ Q x *)
apply (rule impI) (* ⋀x. ⟦P a ⟶ (∀x. Q x); P a⟧ ⟹ Q x *)
apply (drule mp) (* ⋀x. P a ⟹ P a
⋀x. ⟦P a; ∀x. Q x⟧ ⟹ Q x *)
apply assumption (* ⋀x. ⟦P a; ∀x. Q x⟧ ⟹ Q x *)
apply (erule allE) (* ⋀x. ⟦P a; Q (?x7 x)⟧ ⟹ Q x *)
apply assumption (* *)
done

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 ej20: "⟦∀x y z. R x y ∧ R y z ⟶ R x z;
∀x. ¬(R x x)⟧
⟹ ∀x y. R x y ⟶ ¬(R y x)"
apply (rule allI)+ (* ⋀x y. ⟦∀x y z. R x y ∧ R y z ⟶ R x z;
∀x. ¬ R x x⟧
⟹ R x y ⟶ ¬ R y x *)
apply (rule impI) (* ⋀x y. ⟦∀x y z. R x y ∧ R y z ⟶ R x z;
∀x. ¬ R x x;
R x y⟧
⟹ ¬ R y x *)
apply (rule notI) (* ⋀x y. ⟦∀x y z. R x y ∧ R y z ⟶ R x z;
∀x. ¬ R x x;
R x y;
R y x⟧
⟹ False *)
apply (erule_tac x=x in allE) (* ⋀x y. ⟦∀x. ¬ R x x;
R x y;
R y x;
∀y z. R x y ∧ R y z ⟶ R x z⟧
⟹ False *)
apply (erule_tac x=x in allE) (* ⋀x y. ⟦R x y;
R y x;
∀y z. R x y ∧ R y z ⟶ R x z;
¬ R x x⟧
⟹ False *)
apply (erule_tac x=y in allE) (* ⋀x y. ⟦R x y;
R y x;
¬ R x x;
∀z. R x y ∧ R y z ⟶ R x z⟧
⟹ False *)
apply (erule_tac x=x in allE) (* ⋀x y. ⟦R x y;
R y x;
¬ R x x;
R x y ∧ R y x ⟶ R x x⟧
⟹ False *)
apply (erule notE) (* ⋀x y. ⟦R x y;
R y x;
R x y ∧ R y x ⟶ R x x⟧
⟹ R x x *)
apply (erule mp) (* ⋀x y. ⟦R x y;
R y x⟧
⟹ R x y ∧ R y x*)
apply (erule conjI) (* ⋀x y. R y x ⟹ R y x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
{∀x. P x ∨ Q x, ∃x. ¬(Q x), ∀x. R x ⟶ ¬(P x)} ⊢ ∃x. ¬(R x)
------------------------------------------------------------------ *}

lemma ej21: "⟦ ∀x. P x ∨ Q x;
∃x. ¬(Q x);
∀x. R x ⟶ ¬(P x) ⟧
⟹ ∃x. ¬(R x)"
apply (erule exE) (* ⋀x. ⟦∀x. P x ∨ Q x; ∀x. R x ⟶ ¬ P x; ¬ Q x⟧
⟹ ∃x. ¬ R x*)
apply (erule_tac x=x in allE)+
(* ⋀x. ⟦¬ Q x; P x ∨ Q x; R x ⟶ ¬ P x⟧
⟹ ∃x. ¬ R x *)
apply (erule disjE) (* ⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; P x⟧ ⟹ ∃x. ¬ R x
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x*)
apply (rule_tac x=x in exI)
(* ⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; P x⟧ ⟹ ¬ R x
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply (rule notI) (* ⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; P x; R x⟧ ⟹ False
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply (drule mp) (* ⋀x. ⟦¬ Q x; P x; R x⟧ ⟹ R x
⋀x. ⟦¬ Q x; P x; R x; ¬ P x⟧ ⟹ False
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply assumption (* ⋀x. ⟦¬ Q x; P x; R x; ¬ P x⟧ ⟹ False
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply (erule_tac P="P x" in notE)
(* ⋀x. ⟦¬ Q x; P x; R x⟧ ⟹ P x
⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply assumption (* ⋀x. ⟦¬ Q x; R x ⟶ ¬ P x; Q x⟧ ⟹ ∃x. ¬ R x *)
apply (erule notE) (* ⋀x. ⟦R x ⟶ ¬ P x; Q x⟧ ⟹ Q x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
{∀x. P x ⟶ Q x ∨ R x, ¬(∃x. P x ∧ R x)} ⊢ ∀x. P x ⟶ Q x
------------------------------------------------------------------ *}

lemma ej22: "⟦ ∀x. P x ⟶ Q x ∨ R x;
¬(∃x. P x ∧ R x) ⟧
⟹ ∀x. P x ⟶ Q x"
apply (rule allI) (* ⋀x. ⟦∀x. P x ⟶ Q x ∨ R x; ∄x. P x ∧ R x⟧
⟹ P x ⟶ Q x *)
apply (rule impI) (* ⋀x. ⟦∀x. P x ⟶ Q x ∨ R x; ∄x. P x ∧ R x; P x⟧
⟹ Q x*)
apply (erule_tac x=x in allE)
(* ⋀x. ⟦∄x. P x ∧ R x; P x; P x ⟶ Q x ∨ R x⟧
⟹ Q x *)
apply (drule mp) (* ⋀x. ⟦∄x. P x ∧ R x; P x⟧ ⟹ P x
⋀x. ⟦∄x. P x ∧ R x; P x; Q x ∨ R x⟧ ⟹ Q x *)
apply assumption (* ⋀x. ⟦∄x. P x ∧ R x; P x; Q x ∨ R x⟧ ⟹ Q x *)
apply (erule disjE) (* ⋀x. ⟦∄x. P x ∧ R x; P x; Q x⟧ ⟹ Q x
⋀x. ⟦∄x. P x ∧ R x; P x; R x⟧ ⟹ Q x *)
apply assumption (* ⋀x. ⟦∄x. P x ∧ R x; P x; R x⟧ ⟹ Q x *)
apply (erule notE) (* ⋀x. ⟦P x; R x⟧ ⟹ ∃x. P x ∧ R x *)
apply (rule_tac x=x in exI)
(* ⋀x. ⟦P x; R x⟧ ⟹ P x ∧ R x *)
apply (erule conjI) (* ⋀x. R x ⟹ R x *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
∃x y. R x y ∨ R y x ⊢ ∃x y. R x y
------------------------------------------------------------------ *}

lemma ej23a: "∃x y. R x y ∨ R y x ⟹ ∃x y. R x y"
apply (erule exE)+ (* ⋀x y. R x y ∨ R y x ⟹ ∃x y. R x y *)
apply (erule disjE) (* ⋀x y. R x y ⟹ ∃x y. R x y
⋀x y. R y x ⟹ ∃x y. R x y *)
apply (rule_tac x=x in exI)
(* ⋀x y. R x y ⟹ ∃y. R x y
⋀x y. R y x ⟹ ∃x y. R x y *)
apply (rule_tac x=y in exI)
(* ⋀x y. R x y ⟹ R x y
⋀x y. R y x ⟹ ∃x y. R x y *)
apply assumption (* ⋀x y. R y x ⟹ ∃x y. R x y *)
apply (rule_tac x=y in exI)
(* ⋀x y. R y x ⟹ ∃ya. R y ya *)
apply (erule_tac x=x in exI)
(* *)
done

lemma ej23b: "∃x y. R x y ∨ R y x ⟹ ∃x y. R x y"
apply (erule exE)+ (* ⋀x y. R x y ∨ R y x ⟹ ∃x y. R x y *)
apply (erule disjE) (* ⋀x y. R x y ⟹ ∃x y. R x y
⋀x y. R y x ⟹ ∃x y. R x y *)
apply (rule exI)+ (* ⋀x y. R x y ⟹ R (?x7 x y) (?y9 x y)
⋀x y. R y x ⟹ ∃x y. R x y *)
apply assumption (* ⋀x y. R y x ⟹ ∃x y. R x y *)
apply (rule exI)+ (* ⋀x y. R y x ⟹ R (?x11 x y) (?y13 x y) *)
apply assumption (* *)
done

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

lemma ej24: "(∃x. ∀y. P x y) ⟶ (∀y. ∃x. P x y)"
apply (rule impI) (* ∃x. ∀y. P x y ⟹ ∀y. ∃x. P x y *)
apply (rule allI) (* ⋀y. ∃x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule exE) (* ⋀y x. ∀y. P x y ⟹ ∃x. P x y *)
apply (erule allE) (* ⋀y x. P x (?y6 y x) ⟹ ∃x. P x y *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)
------------------------------------------------------------------ *}

lemma ej25a: "(∀x. P x ⟶ Q) ⟹ ((∃x. P x) ⟶ Q)"
apply (rule impI) (* ∀x. P x ⟶ Q; ∃x. P x⟧ ⟹ Q *)
apply (erule exE) (* ⋀x. ⟦∀x. P x ⟶ Q; P x⟧ ⟹ Q *)
apply (erule allE) (* ⋀x. ⟦P x; P (?x7 x) ⟶ Q⟧ ⟹ Q *)
apply (erule mp) (* ⋀x. P x ⟹ P (?x7 x) *)
apply assumption (* *)
done

lemma ej25b: "((∃x. P x) ⟶ Q) ⟹ (∀x. P x ⟶ Q)"
apply (rule allI) (* ⋀x. (∃x. P x) ⟶ Q ⟹ P x ⟶ Q *)
apply (rule impI) (* ⋀x. ⟦(∃x. P x) ⟶ Q; P x⟧ ⟹ Q *)
apply (erule mp) (* ⋀x. P x ⟹ ∃x. P x *)
apply (erule exI) (* *)
done

lemma ej25: "(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)"
apply (rule iffI) (* ∀x. P x ⟶ Q ⟹ (∃x. P x) ⟶ Q
(∃x. P x) ⟶ Q ⟹ ∀x. P x ⟶ Q *)
apply (erule ej25a) (* (∃x. P x) ⟶ Q ⟹ ∀x. P x ⟶ Q *)
apply (erule ej25b) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)
------------------------------------------------------------------ *}

lemma ej26a: "((∀x. P x) ∧ (∀x. Q x)) ⟹ (∀x. P x ∧ Q x)"
apply (rule allI) (* ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ P x ∧ Q x *)
apply (rule conjI) (* ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ P x
⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x *)
apply (drule conjunct1) (* ⋀x. ∀x. P x ⟹ P x
⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x *)
apply (erule spec) (* ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x *)
apply (drule conjunct2) (* ⋀x. ∀x. Q x ⟹ Q x *)
apply (erule spec) (* *)
done

lemma ej26b: "(∀x. P x ∧ Q x) ⟹ ((∀x. P x) ∧ (∀x. Q x))"
apply (rule conjI) (* ∀x. P x ∧ Q x ⟹ ∀x. P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (rule allI) (* ⋀x. ∀x. P x ∧ Q x ⟹ P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (drule spec) (* ⋀x. P (?x19 x) ∧ Q (?x19 x) ⟹ P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (erule conjunct1) (* ∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (rule allI) (* ⋀x. ∀x. P x ∧ Q x ⟹ Q x *)
apply (drule spec) (* ⋀x. P (?x24 x) ∧ Q (?x24 x) ⟹ Q x *)
apply (erule conjunct2) (* *)
done

lemma ej26: "((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)"
apply (rule iffI) (* (∀x. P x) ∧ (∀x. Q x) ⟹ ∀x. P x ∧ Q x
∀x. P x ∧ Q x ⟹ (∀x. P x) ∧ (∀x. Q x) *)
apply (erule ej26a) (* ∀x. P x ∧ Q x ⟹ (∀x. P x) ∧ (∀x. Q x) *)
apply (erule ej26b) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar o refutar
((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)
------------------------------------------------------------------ *}

lemma ej27: "((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)"
oops

(* Auto Quickcheck found a counterexample:
P = {a1}
Q = {a2}
Evaluated terms:
∀x xa. P x ∨ Q xa = False
∀x. P x ∨ Q x = True *)

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar o refutar
((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)
------------------------------------------------------------------ *}

lemma ej28a: "((∃x. P x) ∨ (∃x. Q x)) ⟹ (∃x. P x ∨ Q x)"
apply (erule disjE) (* ∃x. P x ⟹ ∃x. P x ∨ Q x
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule exE) (* ⋀x. P x ⟹ ∃x. P x ∨ Q x
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (rule exI) (* ⋀x. P x ⟹ P (?x8 x) ∨ Q (?x8 x)
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule disjI1) (* ∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule exE) (* ⋀x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (rule exI) (* ⋀x. Q x ⟹ P (?x13 x) ∨ Q (?x13 x) *)
apply (erule disjI2) (* *)
done

lemma ej28b: "(∃x. P x ∨ Q x) ⟹ ((∃x. P x) ∨ (∃x. Q x))"
apply (erule exE) (* ⋀x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule disjE) (* ⋀x. P x ⟹ (∃x. P x) ∨ (∃x. Q x)
⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (rule disjI1) (* ⋀x. P x ⟹ ∃x. P x
⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule exI) (* ⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (rule disjI2) (* ⋀x. Q x ⟹ ∃x. Q x *)
apply (erule exI) (* *)
done

lemma ej28: "((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)"
apply (rule iffI) (* (∃x. P x) ∨ (∃x. Q x) ⟹ ∃x. P x ∨ Q x
∃x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule ej28a) (* ∃x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule ej28b) (* *)
done

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

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

(* Auto Quickcheck found a counterexample:
P = (λx. undefined)(a⇩1 := {a⇩2}, a⇩2 := {a⇩1})
*)

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar o refutar
(¬(∀x. P x)) ⟷ (∃x. ¬P x)
------------------------------------------------------------------ *}

lemma ej30a: "¬(∀x. P x) ⟹ (∃x. ¬P x)"
apply (rule ccontr) (* ⟦¬ (∀x. P x); ∄x. ¬ P x⟧ ⟹ False *)
apply (erule notE) (* ∄x. ¬ P x ⟹ ∀x. P x *)
apply (rule allI) (* ⋀x. ∄x. ¬ P x ⟹ P x *)
apply (rule ccontr) (* ⋀x. ⟦∄x. ¬ P x; ¬ P x⟧ ⟹ False *)
apply (erule notE) (* ⋀x. ¬ P x ⟹ ∃x. ¬ P x *)
apply (erule exI) (* *)
done

lemma ej30b: "(∃x. ¬P x) ⟹ ¬(∀x. P x)"
apply (rule notI) (* ⟦¬ (∀x. P x); ∄x. ¬ P x⟧ ⟹ False *)
apply (erule exE) (* ⋀x. ⟦∀x. P x; ¬ P x⟧ ⟹ False *)
apply (drule spec) (* ⋀x. ⟦¬ P x; P (?x4 x)⟧ ⟹ False *)
apply (erule notE) (* ⋀x. P (?x4 x) ⟹ P x *)
apply assumption (* *)
done

lemma ej30: "(¬(∀x. P x)) ⟷ (∃x. ¬P x)"
apply (rule iffI) (* ¬ (∀x. P x) ⟹ ∃x. ¬ P x
∃x. ¬ P x ⟹ ¬ (∀x. P x) *)
apply (erule ej30a) (* ∃x. ¬ P x ⟹ ¬ (∀x. P x) *)
apply (erule ej30b) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 31. 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 ej31: "⟦ ∀x. P a x x;
∀x y z. P x y z ⟶ P (f x) y (f z) ⟧
⟹ P (f a) a (f a)"
apply (erule allE)+ (* ⟦P a ?x ?x;
P ?x2 ?y4 ?z6 ⟶ P (f ?x2) ?y4 (f ?z6)⟧
⟹ P (f a) a (f a) *)
apply (erule mp) (* P a ?x ?x ⟹ P a a a *)
apply assumption (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 32. 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 ej32: "⟦ ∀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))"
apply (erule allE)+ (* ⟦P a ?x ?x;
P ?x2 ?y4 ?z6 ⟶ P (f ?x2) ?y4 (f ?z6)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply (drule mp) (* P a ?x ?x ⟹ P ?x2 ?y4 ?z6
⟦P a ?x ?x; P (f ?x2) ?y4 (f ?z6)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply assumption (* ⟦P a ?x ?x; P (f a) ?x (f ?x)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply (erule exI) (* *)
done

text {* ---------------------------------------------------------------
Ejercicio 33. 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 ej33: "⟦ ∀y. Q a y;
∀x y. Q x y ⟶ Q (s x) (s y) ⟧
⟹ ∃z. Q a z ∧ Q z (s (s a))"
apply (erule allE)+ (* ⟦Q a ?y;
Q ?x2 ?y4 ⟶ Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a)) *)
apply (drule mp) (* Q a ?y ⟹ Q ?x2 ?y4
⟦Q a ?y; Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a)) *)
apply assumption (* ⟦Q a ?y; Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a))*)
apply (rule exI) (* ⟦Q a ?y; Q (s a) (s ?y)⟧
⟹ Q a ?z9 ∧ Q ?z9 (s (s a)) *)
apply (rule conjI) (* ⟦Q a ?y; Q (s a) (s ?y)⟧ ⟹ Q a ?z9
⟦Q a ?y; Q (s a) (s ?y)⟧ ⟹ Q ?z9 (s (s a)) *)
apply assumption+ (* *)
done

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:
"⟦∀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))"
apply (erule allE)+ (* ⟦P a ?x ?x;
P ?x2 ?y4 ?z6 ⟶ P (f ?x2) ?y4 (f ?z6)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply (drule mp) (* P a ?x ?x ⟹ P ?x2 ?y4 ?z6
⟦P a ?x ?x; P (f ?x2) ?y4 (f ?z6)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply assumption (* ⟦P a ?x ?x; P (f ?x2) ?y4 (f ?z6)⟧
⟹ ∃z. P (f a) z (f (f a)) *)
apply (erule exI) (* *)
done

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:
"⟦∀y. Q a y;
∀x y. Q x y ⟶ Q (s x) (s y)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a))"
apply (erule allE)+ (* ⟦Q a ?y; Q ?x2 ?y4 ⟶ Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a)) *)
apply (drule mp) (* Q a ?y ⟹ Q ?x2 ?y4
⟦Q a ?y; Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a)) *)
apply assumption (* ⟦Q a ?y; Q (s ?x2) (s ?y4)⟧
⟹ ∃z. Q a z ∧ Q z (s (s a)) *)
apply (rule exI) (* ⟦Q a ?y; Q (s a) (s ?y)⟧
⟹ Q a ?z9 ∧ Q ?z9 (s (s a)) *)
apply (rule conjI) (* ⟦Q a ?y; Q (s a) (s ?y)⟧ ⟹ Q a ?z9
⟦Q a ?y; Q (s a) (s ?y)⟧ ⟹ Q ?z9 (s (s a)) *)
apply assumption+ (* *)
done

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"
apply(drule sym) (* ⟦odd (f x); f x = x⟧ ⟹ odd x *)
apply (drule subst) (* odd (f x) ⟹ ?P2 (f x)
⟦odd (f x); ?P2 x⟧ ⟹ odd x *)
apply assumption (* ⟦odd (f x); odd x⟧ ⟹ odd x*)
apply assumption (* *)
done

lemma ejercicio_36b:
"⟦x = f x; odd (f x)⟧ ⟹ odd x"
apply (erule ssubst) (* odd (f x) ⟹ odd (f x) *)
apply assumption (* *)
done

lemma ejercicio_36c:
"⟦x = f x; odd (f x)⟧ ⟹ odd x"
by (rule ssubst)

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"
apply (drule sym) (* ⟦triple (f x) (f x) x; f x = x⟧
⟹ triple x x x *)
apply (drule subst) (* triple (f x) (f x) x ⟹ ?P2 (f x)
⟦triple (f x) (f x) x; ?P2 x⟧ ⟹ triple x x x *)
apply assumption (* ⟦triple (f x) (f x) x; triple x x x⟧
⟹ triple x x x *)
apply assumption (* *)
done

lemma ejercicio_37b:
"⟦x = f x; triple (f x) (f x) x⟧ ⟹ triple x x x"
apply (drule_tac s="f x" in ssubst)
(* triple (f x) (f x) x ⟹ ?P (f x)
⟦triple (f x) (f x) x; ?P x⟧ ⟹ triple x x x *)
apply assumption (* ⟦triple (f x) (f x) x; triple x x x⟧
⟹ triple x x x *)
apply assumption (* *)
done

lemma ejercicio_37c:
"⟦x = f x; triple (f x) (f x) x⟧ ⟹ triple x x x"
by (rule ssubst)

end
</source>

Ejercicios

2019-04-21T09:25:21Z

Jalonso:

Sol 6

2019-04-21T09:22:14Z

Jalonso:

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

theory R6
imports Main
begin

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

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

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

text {*
Se usarán las reglas notnotI 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)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_1a:
"∀x. P x ⟶ Q x ⟹ (∀x. P x) ⟶ (∀x. Q x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_1b:
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` ..
have "P a ⟶ Q a" using assms(1) ..
thus "Q a" using `P a` ..
qed
qed

― ‹La demostración detallada es›
lemma ejercicio_1c:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. P x) ⟶ (∀x. Q x)"
proof (rule impI)
assume "∀x. P x"
show "∀x. Q x"
proof (rule allI)
fix a
have "P a" using `∀x. P x` by (rule allE)
have "P a ⟶ Q a" using assms(1) by (rule allE)
thus "Q a" using `P a` by (rule mp)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 2. Demostrar
∃x. ¬(P x) ⊢ ¬(∀x. P x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_2a: "∃x. ¬(P x) ⟹ ¬(∀x. P x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_2b:
assumes "∃x. ¬(P x)"
shows "¬(∀x. P x)"
proof
assume "∀x. P x"
obtain a where "¬(P a)" using assms(1) ..
have "P a" using `∀x. P x` ..
with `¬(P a)` show False ..
qed

― ‹La demostración detallada es›
lemma ejercicio_2c:
assumes "∃x. ¬(P x)"
shows "¬(∀x. P x)"
proof (rule notI)
assume "∀x. P x"
obtain a where "¬(P a)" using assms(1) by (rule exE)
have "P a" using `∀x. P x` by (rule allE)
with `¬(P a)` show False by (rule notE)
qed

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar
∀x. P x ⊢ ∀y. P y
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_3a: "∀x. P x ⟹ ∀y. P y"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_3b:
assumes "∀x. P x"
shows "∀y. P y"
proof
fix a
show "P a" using assms ..
qed

― ‹La demostración estructurada es›
lemma ejercicio_3c:
assumes "∀x. P x"
shows "∀y. P y"
proof (rule allI)
fix a
show "P a" using assms by (rule allE)
qed

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar
∀x. P x ⟶ Q x ⊢ (∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_4a:
"∀x. P x ⟶ Q x ⟹ (∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_4b:
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
show "¬(P a)"
proof
assume "P a"
have "P a ⟶ Q a" using assms ..
hence "Q a" using `P a` ..
have "¬(Q a)" using `∀x. ¬(Q x)` ..
thus False using `Q a` ..
qed
qed
qed

― ‹La demostración detallada es›
lemma ejercicio_4c:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. ¬(Q x)) ⟶ (∀x. ¬ (P x))"
proof (rule impI)
assume "∀x. ¬(Q x)"
show "∀x. ¬(P x)"
proof (rule allI)
fix a
show "¬(P a)"
proof
assume "P a"
have "P a ⟶ Q a" using assms by (rule allE)
hence "Q a" using `P a` by (rule mp)
have "¬(Q a)" using `∀x. ¬(Q x)` by (rule allE)
thus False using `Q a` by (rule notE)
qed
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 5. Demostrar
∀x. P x ⟶ ¬(Q x) ⊢ ¬(∃x. P x ∧ Q x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_5a:
"∀x. P x ⟶ ¬(Q x) ⟹ ¬(∃x. P x ∧ Q x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_5b:
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

― ‹La demostración estructurada es›
lemma ejercicio_5c:
assumes "∀x. P x ⟶ ¬(Q x)"
shows "¬(∃x. P x ∧ Q x)"
proof (rule notI)
assume "∃x. P x ∧ Q x"
then obtain a where "P a ∧ Q a" by (rule exE)
hence "P a" by (rule conjunct1)
have "P a ⟶ ¬(Q a)" using assms by (rule allE)
hence "¬(Q a)" using `P a` by (rule mp)
have "Q a" using `P a ∧ Q a` by (rule conjunct2)
with `¬(Q a)` show False by (rule notE)
qed

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
∀x y. P x y ⊢ ∀u v. P u v
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_6a:
"∀x y. P x y ⟹ ∀u v. P u v"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_6b:
assumes "∀x y. P x y"
shows "∀u v. P u v"
proof
fix a
show "∀v. P a v"
proof
fix b
have "∀y. P a y" using assms ..
thus "P a b" ..
qed
qed

― ‹La demostración estructurada simplificada es›
lemma ejercicio_6b2:
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

― ‹La demostración detallada es›
lemma ejercicio_6c:
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 by (rule allE)
thus "P a b" by (rule allE)
qed

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
∃x y. P x y ⟹ ∃u v. P u v
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_7a:
"∃x y. P x y ⟹ ∃u v. P u v"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_7b:
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

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
∃x. ∀y. P x y ⊢ ∀y. ∃x. P x y
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_8a:
"∃x. ∀y. P x y ⟹ ∀y. ∃x. P x y"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_8b:
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

― ‹La demostración detallada es›
lemma ejercicio_8c:
assumes "∃x. ∀y. P x y"
shows "∀y. ∃x. P x y"
proof (rule allI)
fix b
obtain a where "∀y. P a y" using assms by (rule exE)
hence "P a b" by (rule allE)
thus "∃x. P x b" by (rule exI)
qed

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

― ‹La demostración automática es›
lemma ejercicio_9a:
"∃x. P a ⟶ Q x ⟹ P a ⟶ (∃x. Q x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_9b:
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

― ‹La demostración detallada es›
lemma ejercicio_9c:
assumes "∃x. P a ⟶ Q x"
shows "P a ⟶ (∃x. Q x)"
proof (rule impI)
assume "P a"
obtain b where "P a ⟶ Q b" using assms by (rule exE)
hence "Q b" using `P a` by (rule mp)
thus "∃x. Q x" by (rule exI)
qed

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

― ‹La demostración automática es›
lemma ejercicio_10a:
"P a ⟶ (∃x. Q x) ⟹ ∃x. P a ⟶ Q x"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_10b:
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" by (rule mp)
then obtain b where "Q b" ..
have "P a ⟶ Q b"
proof
assume "P a"
note `Q b`
thus "Q b" .
qed
thus "∃x. P a ⟶ Q x" ..
qed
qed

― ‹La demostración detallada es›
lemma ejercicio_10c:
fixes P Q :: "'b ⇒ bool"
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
have "¬(P a) ∨ P a" by (rule excluded_middle)
thus "∃x. P a ⟶ Q x"
proof (rule disjE)
assume "¬(P a)"
have "P a ⟶ Q a"
proof (rule impI)
assume "P a"
with `¬(P a)` show "Q a" by (rule notE)
qed
thus "∃x. P a ⟶ Q x" by (rule exI)
next
assume "P a"
with assms have "∃x. Q x" by (rule mp)
then obtain b where "Q b" by (rule exE)
have "P a ⟶ Q b"
proof (rule impI)
assume "P a"
note `Q b`
thus "Q b" by this
qed
thus "∃x. P a ⟶ Q x" by (rule exI)
qed
qed

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

― ‹La demostración automática es›
lemma ejercicio_11a:
"(∃x. P x) ⟶ Q a ⟹ ∀x. P x ⟶ Q a"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_11b:
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

― ‹La demostración detallada es›
lemma ejercicio_11c:
assumes "(∃x. P x) ⟶ Q a"
shows "∀x. P x ⟶ Q a"
proof (rule allI)
fix b
show "P b ⟶ Q a"
proof (rule impI)
assume "P b"
hence "∃x. P x" by (rule exI)
with assms show "Q a" by (rule mp)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar
∀x. P x ⟶ Q a ⊢ ∃ x. P x ⟶ Q a
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_12a:
"∀x. P x ⟶ Q a ⟹ ∃x. P x ⟶ Q a"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_12b:
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
proof -
have "P b ⟶ Q a" using assms ..
thus "∃x. P x ⟶ Q a" ..
qed

― ‹La demostración detallada es›
lemma ejercicio_12c:
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
proof -
have "P b ⟶ Q a" using assms by (rule allE)
thus "∃x. P x ⟶ Q a" by (rule exI)
qed

text {* ---------------------------------------------------------------
Ejercicio 13. Demostrar
(∀x. P x) ∨ (∀x. Q x) ⊢ ∀x. P x ∨ Q x
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_13a:
"(∀x. P x) ∨ (∀x. Q x) ⟹ ∀x. P x ∨ Q x"
by auto

― ‹La demostración estructurada es›
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

― ‹La demostración detallada es›
lemma ejercicio_13c:
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
proof (rule allI)
fix a
note assms
thus "P a ∨ Q a"
proof (rule disjE)
assume "∀x. P x"
hence "P a" by (rule allE)
thus "P a ∨ Q a" by (rule disjI1)
next
assume "∀x. Q x"
hence "Q a" by (rule allE)
thus "P a ∨ Q a" by (rule disjI2)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 14. Demostrar
∃x. P x ∧ Q x ⊢ (∃x. P x) ∧ (∃x. Q x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_14a:
"∃x. P x ∧ Q x ⟹ (∃x. P x) ∧ (∃x. Q x)"
by auto

― ‹La demostración estructurada es›
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

― ‹La demostración detallada es›
lemma ejercicio_14c:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
proof (rule conjI)
obtain a where "P a ∧ Q a" using assms by (rule exE)
hence "P a" by (rule conjunct1)
thus "∃x. P x" by (rule exI)
next
obtain a where "P a ∧ Q a" using assms by (rule exE)
hence "Q a" by (rule conjunct2)
thus "∃x. Q x" by (rule exI)
qed

text {* ---------------------------------------------------------------
Ejercicio 15. Demostrar
∀x y. P y ⟶ Q x ⊢ (∃y. P y) ⟶ (∀x. Q x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_15a:
"∀x y. P y ⟶ Q x ⟹ (∃y. P y) ⟶ (∀x. Q x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_15b:
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

― ‹La demostración detallada es›
lemma ejercicio_15c:
assumes "∀x y. P y ⟶ Q x"
shows "(∃y. P y) ⟶ (∀x. Q x)"
proof (rule impI)
assume "∃y. P y"
then obtain b where "P b" by (rule exE)
show "∀x. Q x"
proof (rule allI)
fix a
have "∀y. P y ⟶ Q a" using assms by (rule allE)
hence "P b ⟶ Q a" by (rule allE)
thus "Q a" using `P b` by (rule mp)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 16. Demostrar
¬(∀x. ¬(P x)) ⊢ ∃x. P x
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_16a:
"¬(∀x. ¬(P x)) ⟹ ∃x. P x"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_16b:
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

― ‹La demostración detallada es›
lemma ejercicio_16c:
assumes "¬(∀x. ¬(P x))"
shows "∃x. P x"
proof (rule ccontr)
assume "¬(∃x. P x)"
have "∀x. ¬(P x)"
proof (rule allI)
fix a
show "¬(P a)"
proof
assume "P a"
hence "∃x. P x" by (rule exI)
with `¬(∃x. P x)` show False by (rule notE)
qed
qed
with assms show False by (rule notE)
qed

text {* ---------------------------------------------------------------
Ejercicio 17. Demostrar
∀x. ¬(P x) ⊢ ¬(∃x. P x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_17a:
"∀x. ¬(P x) ⟹ ¬(∃x. P x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_17b:
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

― ‹La demostración detallada es›
lemma ejercicio_17c:
assumes "∀x. ¬(P x)"
shows "¬(∃x. P x)"
proof (rule notI)
assume "∃x. P x"
then obtain a where "P a" by (rule exE)
have "¬(P a)" using assms by (rule allE)
thus False using `P a` by (rule notE)
qed

text {* ---------------------------------------------------------------
Ejercicio 18. Demostrar
∃x. P x ⊢ ¬(∀x. ¬(P x))
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_18a:
"∃x. P x ⟹ ¬(∀x. ¬(P x))"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_18b:
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)` ..
thus False using `P a` ..
qed

― ‹La demostración detallada es›
lemma ejercicio_18c:
assumes "∃x. P x"
shows "¬(∀x. ¬(P x))"
proof (rule notI)
assume "∀x. ¬(P x)"
obtain a where "P a" using assms by (rule exE)
have "¬(P a)" using `∀x. ¬(P x)` by (rule allE)
thus False using `P a` by (rule notE)
qed

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

― ‹La demostración automática es›
lemma ejercicio_19a:
"P a ⟶ (∀x. Q x) ⟹ ∀x. P a ⟶ Q x"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_19b:
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

― ‹La demostración detallada es›
lemma ejercicio_19c:
assumes "P a ⟶ (∀x. Q x)"
shows "∀x. P a ⟶ Q x"
proof (rule allI)
fix b
show "P a ⟶ Q b"
proof (rule impI)
assume "P a"
with assms have "∀x. Q x" by (rule mp)
thus "Q b" by (rule allE)
qed
qed

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

― ‹La demostración automática es›
lemma ejercicio_20a:
"⟦∀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

― ‹La demostración estructurada es›
lemma ejercicio_20b:
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"
show False
proof -
have "R a b ∧ R b a" using `R a b` `R b a` ..
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` ..
have "¬(R a a)" using assms(2) ..
thus False using `R a a` ..
qed
qed
qed
qed

― ‹La demostración detallada es›
lemma ejercicio_20c:
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 (rule impI)
assume "R a b"
show "¬(R b a)"
proof (rule notI)
assume "R b a"
show False
proof -
have "R a b ∧ R b a" using `R a b` `R b a` by (rule conjI)
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) by (rule allE)
hence "∀z. R a b ∧ R b z ⟶ R a z" by (rule allE)
hence "R a b ∧ R b a ⟶ R a a" by (rule allE)
hence "R a a" using `R a b ∧ R b a` by (rule mp)
have "¬(R a a)" using assms(2) by (rule allE)
thus False using `R a a` by (rule notE)
qed
qed
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 21. Demostrar
{∀x. P x ∨ Q x, ∃x. ¬(Q x), ∀x. R x ⟶ ¬(P x)} ⊢ ∃x. ¬(R x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_21a:
"⟦∀x. P x ∨ Q x; ∃x. ¬(Q x); ∀x. R x ⟶ ¬(P x)⟧ ⟹ ∃x. ¬(R x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_21b:
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 "P a"
proof
assume "P a"
thus "P a" .
next
assume "Q a"
with `¬(Q a)` show "P a" ..
qed
hence "¬¬(P a)" by (rule notnotI)
have "R a ⟶ ¬(P a)" using assms(3) ..
hence "¬(R a)" using `¬¬(P a)` by (rule mt)
thus "∃x. ¬(R x)" ..
qed

― ‹La demostración detallada es›
lemma ejercicio_21c:
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) by (rule exE)
have "P a ∨ Q a" using assms(1) by (rule allE)
hence "P a"
proof (rule disjE)
assume "P a"
thus "P a" by this
next
assume "Q a"
with `¬(Q a)` show "P a" by (rule notE)
qed
hence "¬¬(P a)" by (rule notnotI)
have "R a ⟶ ¬(P a)" using assms(3) by (rule allE)
hence "¬(R a)" using `¬¬(P a)` by (rule mt)
thus "∃x. ¬(R x)" by (rule exI)
qed

text {* ---------------------------------------------------------------
Ejercicio 22. Demostrar
{∀x. P x ⟶ Q x ∨ R x, ¬(∃x. P x ∧ R x)} ⊢ ∀x. P x ⟶ Q x
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_22a:
"⟦∀x. P x ⟶ Q x ∨ R x; ¬(∃x. P x ∧ R x)⟧ ⟹ ∀x. P x ⟶ Q x"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_22b:
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

― ‹La demostración detallada es›
lemma ejercicio_22c:
assumes "∀x. P x ⟶ Q x ∨ R x"
"¬(∃x. P x ∧ R x)"
shows "∀x. P x ⟶ Q x"
proof (rule allI)
fix a
show "P a ⟶ Q a"
proof (rule impI)
assume "P a"
have "P a ⟶ Q a ∨ R a" using assms(1) by (rule allE)
hence "Q a ∨ R a" using `P a` by (rule mp)
thus "Q a"
proof (rule disjE)
assume "Q a"
thus "Q a" by this
next
assume "R a"
with `P a` have "P a ∧ R a" by (rule conjI)
hence "∃x. P x ∧ R x" by (rule exI)
with assms(2) show "Q a" by (rule notE)
qed
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 23. Demostrar
∃x y. R x y ∨ R y x ⊢ ∃x y. R x y
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_23a:
"∃x y. R x y ∨ R y x ⟹ ∃x y. R x y"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_23b:
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

― ‹La demostración detallada es›
lemma ejercicio_23c:
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 by (rule exE)
then obtain b where "R a b ∨ R b a" by (rule exE)
thus "∃x y. R x y"
proof (rule disjE)
assume "R a b"
hence "∃y. R a y" by (rule exI)
thus "∃ x y. R x y" by (rule exI)
next
assume "R b a"
hence "∃y. R b y" by (rule exI)
thus "∃ x y. R x y" by (rule exI)
qed
qed

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

― ‹La demostración automática es›
lemma ejercicio_24a: "(∃x. ∀y. P x y) ⟶ (∀y. ∃x. P x y)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_24b: "(∃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

― ‹La demostración detallada es›
lemma ejercicio_24c: "(∃x. ∀y. P x y) ⟶ (∀y. ∃x. P x y)"
proof (rule impI)
assume "∃x. ∀y. P x y"
then obtain a where "∀y. P a y" by (rule exE)
show "∀y. ∃x. P x y"
proof (rule allI)
fix b
have "P a b" using `∀y. P a y` by (rule allE)
thus "∃x. P x b" by (rule exI)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 25. Demostrar
(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_25a: "(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_25b: "(∀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 b
show "P b ⟶ Q"
proof
assume "P b"
hence "∃x. P x" ..
with `(∃x. P x) ⟶ Q` show "Q" ..
qed
qed
qed

― ‹La demostración detallada es›
lemma ejercicio_25c: "(∀x. P x ⟶ Q) ⟷ ((∃x. P x) ⟶ Q)"
proof (rule iffI)
assume "∀x. P x ⟶ Q"
show "(∃x. P x) ⟶ Q"
proof (rule impI)
assume "∃x. P x"
then obtain a where "P a" by (rule exE)
have "P a ⟶ Q" using `∀x. P x ⟶ Q` by (rule allE)
thus "Q" using `P a` by (rule mp)
qed
next
assume "(∃x. P x) ⟶ Q"
show "∀x. P x ⟶ Q"
proof (rule allI)
fix b
show "P b ⟶ Q"
proof (rule impI)
assume "P b"
hence "∃x. P x" by (rule exI)
with `(∃x. P x) ⟶ Q` show "Q" by (rule mp)
qed
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 26. Demostrar
((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_26a: "((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)"
by auto

― ‹La demostración estructurada es›
lemma ejercicio_26b: "((∀x. P x) ∧ (∀x. Q x)) ⟷ (∀x. P x ∧ Q x)"
proof
assume "(∀x. P x) ∧ (∀x. Q x)"
show "∀x. P x ∧ Q x"
proof
fix a
have "∀x. P x" using `(∀x. P x) ∧ (∀x. Q x)` ..
have "∀x. Q x" using `(∀x. P x) ∧ (∀x. Q x)` ..
hence "Q a" ..
have "P a" using `∀x. P x` ..
thus "P a ∧ Q a" using `Q a` ..
qed
next
assume "∀x. P x ∧ Q x"
have "∀x. P x"
proof
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` ..
thus "P a" ..
qed
moreover have "∀x. Q x"
proof
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` ..
thus "Q a" ..
qed
ultimately show "(∀x. P x) ∧ (∀x. Q x)" ..
qed

― ‹La demostración detallada es›
lemma ejercicio_26c: "((∀x. P x) ∧ (∀x. Q x)) = (∀x. P x ∧ Q x)"
proof (rule iffI)
assume "(∀x. P x) ∧ (∀x. Q x)"
show "∀x. P x ∧ Q x"
proof (rule allI)
fix a
have "∀x. P x" using `(∀x. P x) ∧ (∀x. Q x)` by (rule conjunct1)
have "∀x. Q x" using `(∀x. P x) ∧ (∀x. Q x)` by (rule conjunct2)
hence "Q a" by (rule allE)
have "P a" using `∀x. P x` by (rule allE)
thus "P a ∧ Q a" using `Q a` by (rule conjI)
qed
next
assume "∀x. P x ∧ Q x"
have "∀x. P x"
proof (rule allI)
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` by (rule allE)
thus "P a" by (rule conjunct1)
qed
moreover have "∀x. Q x"
proof (rule allI)
fix a
have "P a ∧ Q a" using `∀x. P x ∧ Q x` by (rule allE)
thus "Q a" by (rule conjunct2)
qed
ultimately show "(∀x. P x) ∧ (∀x. Q x)" by (rule conjI)
qed

text {* ---------------------------------------------------------------
Ejercicio 27. Demostrar o refutar
((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)
------------------------------------------------------------------ *}

lemma ejercicio_27: "((∀x. P x) ∨ (∀x. Q x)) ⟷ (∀x. P x ∨ Q x)"
oops

(*
Auto Quickcheck found a counterexample:
P = {a\<^isub>1}
Q = {a\<^isub>2}
*)

text {* ---------------------------------------------------------------
Ejercicio 28. Demostrar o refutar
((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_28a:
"((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)"
by auto

― ‹La demostración estructurada es›
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

― ‹La demostración detallada es›
lemma ejercicio_28c:
"((∃x. P x) ∨ (∃x. Q x)) ⟷ (∃x. P x ∨ Q x)"
proof (rule iffI)
assume "(∃x. P x) ∨ (∃x. Q x)"
thus "∃x. P x ∨ Q x"
proof (rule disjE)
assume "∃x. P x"
then obtain a where "P a" by (rule exE)
hence "P a ∨ Q a" by (rule disjI1)
thus "∃x. P x ∨ Q x" by (rule exI)
next
assume "∃x. Q x"
then obtain a where "Q a" by (rule exE)
hence "P a ∨ Q a" by (rule disjI2)
thus "∃x. P x ∨ Q x" by (rule exI)
qed
next
assume "∃x. P x ∨ Q x"
then obtain a where "P a ∨ Q a" by (rule exE)
thus "(∃x. P x) ∨ (∃x. Q x)"
proof (rule disjE)
assume "P a"
hence "∃x. P x" by (rule exI)
thus "(∃x. P x) ∨ (∃x. Q x)" by (rule disjI1)
next
assume "Q a"
hence "∃x. Q x" by (rule exI)
thus "(∃x. P x) ∨ (∃x. Q x)" by (rule disjI2)
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)"
quickcheck
(*
Quickcheck found a counterexample:

P = (λx. undefined)(a\<^isub> := {b}, b := {a})
*)
oops

text {* ---------------------------------------------------------------
Ejercicio 30. Demostrar o refutar
(¬(∀x. P x)) ⟷ (∃x. ¬P x)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_30a:
"(¬(∀x. P x)) ⟷ (∃x. ¬P x)"
by auto

― ‹La demostración estructurada es›
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

― ‹La demostración detallada es›
lemma ejercicio_30c:
"(¬(∀x. P x)) ⟷ (∃x. ¬P x)"
proof (rule iffI)
assume "¬(∀x. P x)"
show "∃x. ¬P x"
proof (rule ccontr)
assume "¬(∃x. ¬P x)"
have "∀x. P x"
proof (rule allI)
fix a
show "P a"
proof (rule ccontr)
assume "¬P a"
hence "∃x. ¬P x" by (rule exI)
with `¬(∃x. ¬P x)` show False by (rule notE)
qed
qed
with `¬(∀x. P x)` show False by (rule notE)
qed
next
assume "∃x. ¬P x"
then obtain a where "¬P a" by (rule exE)
show "¬(∀x. P x)"
proof (rule notI)
assume "∀x. P x"
hence "P a" by (rule allE)
show False using `¬P a` `P a` by (rule notE)
qed
qed

section {* Ejercicios sobre igualdad *}

text {* ---------------------------------------------------------------
Ejercicio 31. Demostrar o refutar
P a ⟹ ∀x. x = a ⟶ P x
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_31a:
"P a ⟹ ∀x. x = a ⟶ P x"
by auto

― ‹La demostración estructurada es›
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

― ‹La demostración detallada es›
lemma ejercicio_31c:
assumes "P a"
shows "∀x. x = a ⟶ P x"
proof (rule allI)
fix b
show "b = a ⟶ P b"
proof (rule impI)
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
------------------------------------------------------------------ *}

― ‹La demostración automática es›
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

― ‹La demostración estructurada es›
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 -
obtain a where "∃y. R a y ∨ R y a" using assms(1) ..
then obtain b where "R a b ∨ R b a" ..
hence "a ≠ b"
proof
assume "R a b"
show "a ≠ b"
proof
assume "a = b"
hence "R b b" using `R a b` by (rule subst)
hence "∃x. R x x" ..
with assms(2) show False ..
qed
next
assume "R b a"
show "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
qed
hence "∃y. a ≠ y" ..
thus "∃(x::'c) y. x ≠ y" ..
qed

― ‹La demostración detallada es›
lemma ejercicio_32c:
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 -
obtain a where "∃y. R a y ∨ R y a" using assms(1) by (rule exE)
then obtain b where "R a b ∨ R b a" by (rule exE)
hence "a ≠ b"
proof (rule disjE)
assume "R a b"
show "a ≠ b"
proof (rule notI)
assume "a = b"
hence "R b b" using `R a b` by (rule subst)
hence "∃x. R x x" by (rule exI)
with assms(2) show False by (rule notE)
qed
next
assume "R b a"
show "a ≠ b"
proof (rule notI)
assume "a = b"
hence "R a a" using `R b a` by (rule ssubst)
hence "∃x. R x x" by (rule exI)
with assms(2) show False by (rule notE)
qed
qed
hence "∃y. a ≠ y" by (rule exI)
thus "∃(x::'c) y. x ≠ y" by (rule exI)
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)
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_33a:
"⟦∀x. P a x x; ∀x y z. P x y z ⟶ P (f x) y (f z)⟧ ⟹ P (f a) a (f a)"
by auto

― ‹La demostración estructura es›
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

― ‹La demostración detallada es›
lemma ejercicio_33c:
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) by (rule allE)
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) by (rule allE)
hence "∀z. P a a z ⟶ P (f a) a (f z)" by (rule allE)
hence "P a a a ⟶ P (f a) a (f a)" by (rule allE)
thus "P (f a) a (f a)" using `P a a a` by (rule mp)
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))
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_34a:
"⟦∀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))"
by metis

― ‹La demostración estructura es›
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

― ‹La demostración detallada es›
lemma ejercicio_34c:
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) by (rule allE)
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) by (rule allE)
hence "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" by (rule allE)
hence "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" by (rule allE)
hence "P (f a) (f a) (f (f a))" using `P a (f a) (f a)` by (rule mp)
thus "∃z. P (f a) z (f (f a))" by (rule exI)
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))
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_35a:
"⟦∀y. Q a y; ∀x y. Q x y ⟶ Q (s x) (s y)⟧ ⟹ ∃z. Q a z ∧ Q z (s (s a))"
by auto

― ‹La demostración estructura es›
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

― ‹La demostración detallada es›
lemma ejercicio_35c:
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) by (rule allE)
have "∀y. Q a y ⟶ Q (s a) (s y)" using assms(2) by (rule allE)
hence "Q a (s a) ⟶ Q (s a) (s (s a))" by (rule allE)
hence "Q (s a) (s (s a))" using `Q a (s a)` by (rule mp)
with `Q a (s a)` have "Q a (s a) ∧ Q (s a) (s (s a))" by (rule conjI)
thus "∃z. Q a z ∧ Q z (s (s a))" by (rule exI)
qed

text {* ---------------------------------------------------------------
Ejercicio 36. Demostrar o refutar
{x = f x, odd (f x)} ⊢ odd x
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_36a:
"⟦x = f x; odd (f x)⟧ ⟹ odd x"
by auto

― ‹La demostración semiautomática es›
lemma ejercicio_36b:
"⟦x = f x; odd (f x)⟧ ⟹ odd x"
by (rule ssubst)

― ‹La demostración estructurada es›
lemma ejercicio_36c:
assumes "x = f x"
"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
------------------------------------------------------------------ *}

― ‹La demostración automática es›
lemma ejercicio_37a:
"⟦x = f x; triple (f x) (f x) x⟧ ⟹ triple x x x"
by auto

― ‹La demostración semiautomática es›
lemma ejercicio_37b:
"⟦x = f x; triple (f x) (f x) x⟧ ⟹ triple x x x"
by (rule ssubst)

― ‹La demostración estructurada es›
lemma ejercicio_37c:
assumes "x = f x"
"triple (f x) (f x) x"
shows "triple x x x"
proof -
show "triple x x x" using assms by (rule ssubst)
qed

end
</source>

Sol 7

2019-04-20T12:03:22Z

Jalonso:

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

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 ej1a: "⟦p ⟶ q; p⟧ ⟹ q"
apply (erule mp) (* p ⟹ p *)
apply assumption (* *)
done

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

lemma ej1c: "⟦p ⟶ q; p⟧ ⟹ q"
by (erule mp, assumption)

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

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

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

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

lemma ej2d: "⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r"
by ((erule mp)+, assumption)

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

lemma ej3a: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (drule mp) (* ⟦p ⟶ q; p⟧ ⟹ p
⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q ⟶ r⟧ ⟹ p
⟦p; q ⟶ r; q⟧ ⟹ r *)
apply assumption (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q⟧ ⟹ q
⟦p; q; r⟧ ⟹ r *)
apply assumption (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej3b: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (drule mp, assumption) (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule mp, assumption) (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (drule mp, assumption) (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej3c: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (drule mp, assumption)+ (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej3d: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
apply (drule mp, assumption+)+
done

lemma ej3e: "⟦p ⟶ (q ⟶ r); p ⟶ q; p⟧ ⟹ r"
by (drule mp, assumption+)+

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

lemma ej4a: "⟦p ⟶ q; q ⟶ r⟧ ⟹ p ⟶ r"
apply (rule impI) (* ⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r *)
apply (erule mp) (* ⟦p ⟶ q; p⟧ ⟹ q *)
apply (erule mp) (* p ⟹ p *)
apply assumption (* *)
done

lemma ej4b: "⟦p ⟶ q; q ⟶ r⟧ ⟹ p ⟶ r"
apply (rule impI) (* ⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r *)
apply (erule mp)+ (* p ⟹ p *)
apply assumption (* *)
done

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

lemma ej5a: "p ⟶ (q ⟶ r) ⟹ q ⟶ (p ⟶ r)"
apply (rule impI) (* ⟦p ⟶ q ⟶ r; q⟧ ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r; q; p⟧ ⟹ r *)
apply (erule impE) (* ⟦q; p⟧ ⟹ p
⟦q; p; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦q; p; q ⟶ r⟧ ⟹ r *)
apply (erule impE) (* ⟦q; p⟧ ⟹ q
⟦q; p; r⟧ ⟹ r *)
apply assumption (* ⟦q; p; r⟧ ⟹ r *)
apply assumption (* *)
done

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

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

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

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

lemma ej6a: "p ⟶ (q ⟶ r) ⟹ (p ⟶ q) ⟶ (p ⟶ r)"
apply (rule impI) (* ⟦p ⟶ q ⟶ r; p ⟶ q⟧ ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r; p ⟶ q; p⟧ ⟹ r *)
apply (erule impE) (* ⟦p ⟶ q; p⟧ ⟹ p
⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (erule impE) (* ⟦p; q ⟶ r⟧ ⟹ p
⟦p; q ⟶ r; q⟧ ⟹ r *)
apply assumption (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (erule impE) (* ⟦p; q⟧ ⟹ q
⟦p; q; r⟧ ⟹ r *)
apply assumption (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

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

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

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

lemma ej7a: "p ⟹ q ⟶ p"
apply (rule impI) (* ⟦p; q⟧ ⟹ p *)
apply assumption (* *)
done

lemma ej7b: "p ⟹ q ⟶ p"
apply (rule impI, assumption) (* *)
done

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

lemma ej8a: "p ⟶ (q ⟶ p)"
apply (rule impI) (* p ⟹ q ⟶ p *)
apply (rule impI) (* ⟦p; q⟧ ⟹ p *)
apply assumption (* *)
done

lemma ej8b: "p ⟶ (q ⟶ p)"
apply (rule impI)+ (* ⟦p; q⟧ ⟹ p *)
apply assumption (* *)
done

lemma ej8c: "p ⟶ (q ⟶ p)"
by (rule impI)+

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

lemma ej9a: "p ⟶ q ⟹ (q ⟶ r) ⟶ (p ⟶ r)"
apply (rule impI) (* ⟦p ⟶ q; q ⟶ r⟧ ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r *)
apply (erule mp) (* ⟦p ⟶ q; p⟧ ⟹ q *)
apply (erule mp) (* p ⟹ p *)
apply assumption (* *)
done

lemma ej9b: "p ⟶ q ⟹ (q ⟶ r) ⟶ (p ⟶ r)"
apply (rule impI)+ (* ⟦p ⟶ q; q ⟶ r; p⟧ ⟹ r *)
apply (erule mp)+ (* p ⟹ p *)
apply assumption (* *)
done

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

lemma ej10a: "p ⟶ (q ⟶ (r ⟶ s)) ⟹ r ⟶ (q ⟶ (p ⟶ s))"
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r⟧ ⟹ q ⟶ p ⟶ s *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r; q⟧ ⟹ p ⟶ s *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r; q; p⟧ ⟹ s *)
apply (drule mp) (* ⟦r; q; p⟧ ⟹ p
⟦r; q; p; q ⟶ r ⟶ s⟧ ⟹ s *)
apply assumption (* ⟦r; q; p; q ⟶ r ⟶ s⟧ ⟹ s *)
apply (drule mp) (* ⟦r; q; p⟧ ⟹ q
⟦r; q; p; r ⟶ s⟧ ⟹ s *)
apply assumption (* ⟦r; q; p; r ⟶ s⟧ ⟹ s *)
apply (erule mp) (* ⟦r; q; p⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej10b: "p ⟶ (q ⟶ (r ⟶ s)) ⟹ r ⟶ (q ⟶ (p ⟶ s))"
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r⟧ ⟹ q ⟶ p ⟶ s *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r; q⟧ ⟹ p ⟶ s *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r ⟶ s; r; q; p⟧ ⟹ s *)
apply (drule mp, assumption) (* ⟦r; q; p; q ⟶ r ⟶ s⟧ ⟹ s *)
apply (drule mp, assumption) (* ⟦r; q; p; r ⟶ s⟧ ⟹ s *)
apply (erule mp, assumption) (* *)
done

lemma ej10c: "p ⟶ (q ⟶ (r ⟶ s)) ⟹ r ⟶ (q ⟶ (p ⟶ s))"
apply (rule impI)+ (* ⟦p ⟶ q ⟶ r ⟶ s; r; q; p⟧ ⟹ s *)
apply (drule mp, assumption+)+ (* *)
done

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

lemma ej11a: "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
apply (rule impI) (* p ⟶ q ⟶ r ⟹ (p ⟶ q) ⟶ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r; p ⟶ q⟧ ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ⟶ r; p ⟶ q; p⟧ ⟹ r *)
apply (drule mp) (* ⟦p ⟶ q; p⟧ ⟹ p
⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q ⟶ r⟧ ⟹ p
⟦p; q ⟶ r; q⟧ ⟹ r *)
apply assumption (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej11b: "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
apply (rule impI)+ (* ⟦p ⟶ q ⟶ r; p ⟶ q; p⟧ ⟹ r *)
apply (drule mp, assumption+)+ (* *)
done

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

lemma ej12a: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI) (* ⟦(p ⟶ q) ⟶ r; p⟧ ⟹ q ⟶ r *)
apply (rule impI) (* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q⟧ ⟹ p ⟶ q
⟦p; q; r⟧ ⟹ r *)
apply (rule impI) (* ⟦p; q; p⟧ ⟹ q
⟦p; q; r⟧ ⟹ r *)
apply assumption (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej12b: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+ (* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q⟧ ⟹ p ⟶ q
⟦p; q; r⟧ ⟹ r *)
apply (rule impI) (* ⟦p; q; p⟧ ⟹ q
⟦p; q; r⟧ ⟹ r *)
apply assumption+ (* *)
done

lemma ej12c: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+ (* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q⟧ ⟹ p ⟶ q
⟦p; q; r⟧ ⟹ r *)
apply (rule impI,
assumption+) (* *)
done

lemma ej12e: "(p ⟶ q) ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+ (* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ r *)
apply (rule_tac P="p ⟶ q" in mp)
(* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ (p ⟶ q) ⟶ r
⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ p ⟶ q *)
apply assumption (* ⟦(p ⟶ q) ⟶ r; p; q⟧ ⟹ p ⟶ q *)
apply (rule impI) (* ⟦(p ⟶ q) ⟶ r; p; q; p⟧ ⟹ q *)
apply assumption (* *)
done

section {* Conjunciones *}

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

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

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

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

lemma ej13d: "⟦p; q⟧ ⟹ p ∧ q"
by (rule conjI, assumption+)

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

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

lemma ej14b: "p ∧ q ⟹ p"
by (erule conjunct1)

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

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

lemma ej15b: "p ∧ q ⟹ q"
by (erule conjunct2)

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

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

lemma ej16b: "p ∧ (q ∧ r) ⟹ (p ∧ q) ∧ r"
apply (rule conjI)+ (* p ∧ (q ∧ r) ⟹ p
p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply (erule conjE) (* ⟦p; q ∧ r⟧ ⟹ p
p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply assumption (* p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply (erule conjE)+ (* ⟦p; q; r⟧ ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply assumption (* p ∧ (q ∧ r) ⟹ r *)
apply (erule conjE)+ (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej16c: "p ∧ (q ∧ r) ⟹ (p ∧ q) ∧ r"
apply (rule conjI)+ (* p ∧ (q ∧ r) ⟹ p
p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply (erule conjE,
assumption) (* p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply ((erule conjE)+,
assumption) (* p ∧ (q ∧ r) ⟹ r *)
apply ((erule conjE)+,
assumption) (* *)
done

lemma ej16d: "p ∧ (q ∧ r) ⟹ (p ∧ q) ∧ r"
apply (rule conjI)+ (* p ∧ (q ∧ r) ⟹ p
p ∧ (q ∧ r) ⟹ q
p ∧ (q ∧ r) ⟹ r *)
apply ((erule conjE)+,
assumption)+ (* *)
done

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

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

lemma ej17b: "(p ∧ q) ∧ r ⟹ p ∧ (q ∧ r)"
apply (erule conjE) (* ⟦p ∧ q; r⟧ ⟹ p ∧ (q ∧ r) *)
apply (erule conjE) (* ⟦r; p; q⟧ ⟹ p ∧ (q ∧ r) *)
apply (erule conjI) (* ⟦r; q⟧ ⟹ q ∧ r *)
apply (erule conjI) (* r ⟹ r *)
apply assumption (* *)
done

lemma ej17c: "(p ∧ q) ∧ r ⟹ p ∧ (q ∧ r)"
apply (erule conjE)+ (* ⟦r; p; q⟧ ⟹ p ∧ (q ∧ r) *)
apply (erule conjI)+ (* r ⟹ r *)
apply assumption (* *)
done

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

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

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

lemma ej19a: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
apply (rule impI) (* ⟦(p ⟶ q) ∧ (p ⟶ r); p⟧ ⟹ q ∧ r *)
apply (rule conjI) (* ⟦(p ⟶ q) ∧ (p ⟶ r); p⟧ ⟹ q
⟦(p ⟶ q) ∧ (p ⟶ r); p⟧ ⟹ r *)
apply (drule conjunct1) (* ⟦p; p ⟶ q⟧ ⟹ q *)
apply (erule mp) (* p ⟹ p
⟦(p ⟶ q) ∧ (p ⟶ r); p⟧ ⟹ r *)
apply assumption (* ⟦(p ⟶ q) ∧ (p ⟶ r); p⟧ ⟹ r *)
apply (drule conjunct2) (* ⟦p; p ⟶ r⟧ ⟹ r *)
apply (erule mp) (* p ⟹ p *)
apply assumption (* *)
done

lemma ej19b: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
apply (erule conjE) (* ⟦p ⟶ q; p ⟶ r⟧ ⟹ p ⟶ q ∧ r *)
apply (rule impI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q ∧ r *)
apply (rule conjI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q
⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply (erule mp) (* ⟦p ⟶ r; p⟧ ⟹ p
⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply assumption (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply (erule mp) (* ⟦p ⟶ q; p⟧ ⟹ p *)
apply assumption (* *)
done

lemma ej19c: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
apply (erule conjE) (* ⟦p ⟶ q; p ⟶ r⟧ ⟹ p ⟶ q ∧ r *)
apply (rule impI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q ∧ r *)
apply (rule conjI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q
⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply (erule mp,
assumption) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply (erule mp,
assumption) (* *)
done

lemma ej19d: "(p ⟶ q) ∧ (p ⟶ r) ⟹ p ⟶ q ∧ r"
apply (erule conjE) (* ⟦p ⟶ q; p ⟶ r⟧ ⟹ p ⟶ q ∧ r *)
apply (rule impI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q ∧ r *)
apply (rule conjI) (* ⟦p ⟶ q; p ⟶ r; p⟧ ⟹ q
⟦p ⟶ q; p ⟶ r; p⟧ ⟹ r *)
apply (erule mp,
assumption)+ (* *)
done

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

lemma ej20a: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (drule mp) (* p ⟹ p
⟦p; q ∧ r⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply assumption (* ⟦p; q ∧ r⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (erule conjunct1) (* p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ r *)
apply (drule mp) (* p ⟹ p
⟦p; q ∧ r⟧ ⟹ r *)
apply assumption (* ⟦p; q ∧ r⟧ ⟹ r *)
apply (erule conjunct2) (* *)
done

lemma ej20b: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (drule mp,
assumption) (* ⟦p; q ∧ r⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (erule conjunct1) (* p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ r *)
apply (drule mp,
assumption) (* ⟦p; q ∧ r⟧ ⟹ r *)
apply (erule conjunct2) (* *)
done

lemma ej20c: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (drule mp,
assumption,
erule conjunct1) (* p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI) (* ⟦p ⟶ q ∧ r; p⟧ ⟹ r *)
apply (drule mp,
assumption,
erule conjunct2) (* *)
done

lemma ej20d: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI,
drule mp,
assumption,
erule conjunct1) (* p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI,
drule mp,
assumption,
erule conjunct2) (* *)
done

lemma ej20e: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI,
drule mp,
assumption,
erule conjE) (* ⟦p; q; r⟧ ⟹ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply assumption (* p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI,
drule mp,
assumption,
erule conjE) (* ⟦p; q; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej20f: "p ⟶ q ∧ r ⟹ (p ⟶ q) ∧ (p ⟶ r)"
apply (rule conjI) (* p ⟶ q ∧ r ⟹ p ⟶ q
p ⟶ q ∧ r ⟹ p ⟶ r *)
apply (rule impI,
drule mp,
assumption,
erule conjE,
assumption)+ (* *)
done

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

lemma ej21a: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
apply (rule impI) (* ⟦p ⟶ (q ⟶ r); p ∧ q⟧ ⟹ r *)
apply (frule conjunct1) (* ⟦p ⟶ (q ⟶ r); p ∧ q; p⟧ ⟹ r *)
apply (drule mp) (* ⟦p ∧ q; p⟧ ⟹ p
⟦p ∧ q; p; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦p ∧ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule conjunct2) (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej21b: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
apply (rule impI) (* ⟦p ⟶ (q ⟶ r); p ∧ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ⟶ (q ⟶ r); p; q⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q⟧ ⟹ p
⟦p; q; q ⟶ r⟧ ⟹ r *)
apply assumption (* ⟦p; q; q ⟶ r⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej21c: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
apply (rule impI) (* ⟦p ⟶ (q ⟶ r); p ∧ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ⟶ (q ⟶ r); p; q⟧ ⟹ r *)
apply (drule mp,
assumption) (* ⟦p; q; q ⟶ r⟧ ⟹ r *)
apply (erule mp,
assumption) (* *)
done

lemma ej21d: "p ⟶ (q ⟶ r) ⟹ p ∧ q ⟶ r"
apply (rule impI) (* ⟦p ⟶ (q ⟶ r); p ∧ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ⟶ (q ⟶ r); p; q⟧ ⟹ r *)
apply (drule mp,
assumption+)+ (* *)
done

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

lemma ej22a: "p ∧ q ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI) (* ⟦p ∧ q ⟶ r; p⟧ ⟹ q ⟶ r *)
apply (rule impI) (* ⟦p ∧ q ⟶ r; p; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ p ∧ q *)
apply (rule conjI) (* ⟦p; q⟧ ⟹ p
⟦p; q⟧ ⟹ q *)
apply assumption (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej22b: "p ∧ q ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+ (* ⟦p ∧ q ⟶ r; p; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ p ∧ q *)
apply (erule conjI) (* q ⟹ q *)
apply assumption (* *)
done

lemma ej22c: "p ∧ q ⟶ r ⟹ p ⟶ (q ⟶ r)"
apply (rule impI)+ (* ⟦p ∧ q ⟶ r; p; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ p ∧ q *)
apply (erule conjI,
assumption) (* *)
done

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

lemma ej23a: "(p ⟶ q) ⟶ r ⟹ p ∧ q ⟶ r"
apply (rule impI) (* ⟦(p ⟶ q) ⟶ r; p ∧ q⟧ ⟹ r *)
apply (erule mp) (* p ∧ q ⟹ p ⟶ q *)
apply (rule impI) (* ⟦p ∧ q; p⟧ ⟹ q *)
apply (erule conjunct2) (* *)
done

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

lemma ej24a: "p ∧ (q ⟶ r) ⟹ (p ⟶ q) ⟶ r"
apply (rule impI) (* ⟦p ∧ (q ⟶ r); p ⟶ q⟧ ⟹ r *)
apply (frule conjunct1) (* ⟦p ∧ (q ⟶ r); p ⟶ q; p⟧ ⟹ r *)
apply (drule mp) (* ⟦p ∧ (q ⟶ r); p⟧ ⟹ p
⟦p ∧ (q ⟶ r); p; q⟧ ⟹ r *)
apply assumption (* ⟦p ∧ (q ⟶ r); p; q⟧ ⟹ r *)
apply (drule conjunct2) (* p; q; q ⟶ r⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej24b: "p ∧ (q ⟶ r) ⟹ (p ⟶ q) ⟶ r"
apply (rule impI) (* ⟦p ∧ (q ⟶ r); p ⟶ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule mp) (* ⟦p; q ⟶ r⟧ ⟹ p
⟦p; q ⟶ r; q⟧ ⟹ r *)
apply assumption (* ⟦p; q ⟶ r; q⟧ ⟹ r *)
apply (erule mp) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej24c: "p ∧ (q ⟶ r) ⟹ (p ⟶ q) ⟶ r"
apply (rule impI) (* ⟦p ∧ (q ⟶ r); p ⟶ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ⟶ q; p; q ⟶ r⟧ ⟹ r *)
apply (drule mp,
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) (* p ⟹ q ∨ p
q ⟹ q ∨ p *)
apply (erule disjI2) (* q ⟹ q ∨ p *)
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) (* ⟦q ⟶ r; p ∨ q⟧ ⟹ p ∨ r *)
apply (erule disjE) (* ⟦q ⟶ r; p⟧ ⟹ p ∨ r
⟦q ⟶ r; q⟧ ⟹ p ∨ r *)
apply (erule disjI1) (* ⟦q ⟶ r; q⟧ ⟹ p ∨ r *)
apply (drule mp) (* q ⟹ q
⟦q; r⟧ ⟹ p ∨ r *)
apply assumption (* ⟦q; r⟧ ⟹ p ∨ r *)
apply (erule disjI2) (* *)
done

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

lemma ej29: "p ∨ p ⟹ p"
apply (erule disjE) (* p ⟹ p
p ⟹ p *)
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 ej31a: "p ∨ (q ∨ r) ⟹ (p ∨ q) ∨ r"
apply (erule disjE) (* p ⟹ (p ∨ q) ∨ r
q ∨ r ⟹ (p ∨ q) ∨ r *)
apply (rule disjI1) (* p ⟹ p ∨ q
q ∨ r ⟹ (p ∨ q) ∨ r *)
apply (erule disjI1) (* q ∨ r ⟹ (p ∨ q) ∨ r *)
apply (erule disjE) (* q ⟹ (p ∨ q) ∨ r
r ⟹ (p ∨ q) ∨ r *)
apply (rule disjI1) (* q ⟹ p ∨ q
r ⟹ (p ∨ q) ∨ r *)
apply (erule disjI2) (* r ⟹ (p ∨ q) ∨ r *)
apply (erule disjI2) (* *)
done

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

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

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

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

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

lemma ej33a: "p ∧ (q ∨ r) ⟹ (p ∧ q) ∨ (p ∧ r)"
apply (erule conjE) (* ⟦p; q ∨ r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (erule disjE) (* ⟦p; q⟧ ⟹ (p ∧ q) ∨ (p ∧ r)
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (rule disjI1) (* ⟦p; q⟧ ⟹ p ∧ q
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (rule conjI) (* ⟦p; q⟧ ⟹ p
⟦p; q⟧ ⟹ q
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply assumption (* ⟦p; q⟧ ⟹ q
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply assumption (* ⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (rule disjI2) (* ⟦p; r⟧ ⟹ p ∧ r *)
apply (rule conjI) (* ⟦p; r⟧ ⟹ p
⟦p; r⟧ ⟹ r *)
apply assumption (* ⟦p; r⟧ ⟹ r *)
apply assumption (* *)
done

lemma ej33b: "p ∧ (q ∨ r) ⟹ (p ∧ q) ∨ (p ∧ r)"
apply (erule conjE) (* ⟦p; q ∨ r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (erule disjE) (* ⟦p; q⟧ ⟹ (p ∧ q) ∨ (p ∧ r)
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (rule disjI1) (* ⟦p; q⟧ ⟹ p ∧ q
⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (erule conjI,
assumption) (* ⟦p; r⟧ ⟹ (p ∧ q) ∨ (p ∧ r) *)
apply (rule disjI2) (* ⟦p; r⟧ ⟹ p ∧ r *)
apply (erule conjI,
assumption) (* *)
done

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

lemma ej34a: "(p ∧ q) ∨ (p ∧ r) ⟹ p ∧ (q ∨ r)"
apply (erule disjE) (* p ∧ q ⟹ p ∧ (q ∨ r)
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (erule conjE) (* ⟦p; q⟧ ⟹ p ∧ (q ∨ r)
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (rule conjI) (* ⟦p; q⟧ ⟹ p
⟦p; q⟧ ⟹ q ∨ r
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply assumption (* ⟦p; q⟧ ⟹ q ∨ r
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (rule disjI1) (* ⟦p; q⟧ ⟹ q
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply assumption (* p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (erule conjE) (* ⟦p; r⟧ ⟹ p ∧ (q ∨ r) *)
apply (rule conjI) (* ⟦p; r⟧ ⟹ p
⟦p; r⟧ ⟹ q ∨ r *)
apply assumption (* ⟦p; r⟧ ⟹ q ∨ r *)
apply (erule disjI2) (* *)
done

lemma ej34b: "(p ∧ q) ∨ (p ∧ r) ⟹ p ∧ (q ∨ r)"
apply (erule disjE) (* p ∧ q ⟹ p ∧ (q ∨ r)
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (erule conjE) (* ⟦p; q⟧ ⟹ p ∧ (q ∨ r)
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (rule conjI,
assumption) (* ⟦p; q⟧ ⟹ q ∨ r
p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (rule disjI1,
assumption) (* p ∧ r ⟹ p ∧ (q ∨ r) *)
apply (erule conjE) (* ⟦p; r⟧ ⟹ p ∧ (q ∨ r) *)
apply (rule conjI,
assumption) (* ⟦p; r⟧ ⟹ q ∨ r *)
apply (erule disjI2) (* *)
done

lemma ej34c: "(p ∧ q) ∨ (p ∧ r) ⟹ p ∧ (q ∨ r)"
apply (rule conjI) (* (p ∧ q) ∨ (p ∧ r) ⟹ p
(p ∧ q) ∨ (p ∧ r) ⟹ q ∨ r *)
apply (erule disjE) (* p ∧ q ⟹ p
p ∧ r ⟹ p
(p ∧ q) ∨ (p ∧ r) ⟹ q ∨ r *)
apply (erule conjunct1) (* p ∧ r ⟹ p
(p ∧ q) ∨ (p ∧ r) ⟹ q ∨ r *)
apply (erule conjunct1) (* (p ∧ q) ∨ (p ∧ r) ⟹ q ∨ r *)
apply (erule disjE) (* p ∧ q ⟹ q ∨ r
p ∧ r ⟹ q ∨ r *)
apply (drule conjunct2) (* q ⟹ q ∨ r
p ∧ r ⟹ q ∨ r *)
apply (rule disjI1) (* q ⟹ q
p ∧ r ⟹ q ∨ r *)
apply assumption (* p ∧ r ⟹ q ∨ r *)
apply (drule conjunct2) (* r ⟹ q ∨ r *)
apply (erule disjI2) (* *)
done

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

lemma ej35a: "p ∨ (q ∧ r) ⟹ (p ∨ q) ∧ (p ∨ r)"
apply (erule disjE) (* p ⟹ (p ∨ q) ∧ (p ∨ r)
q ∧ r ⟹ (p ∨ q) ∧ (p ∨ r) *)
apply (rule conjI) (* p ⟹ p ∨ q
p ⟹ p ∨ r
q ∧ r ⟹ (p ∨ q) ∧ (p ∨ r) *)
apply (erule disjI1) (* p ⟹ p ∨ r
q ∧ r ⟹ (p ∨ q) ∧ (p ∨ r) *)
apply (erule disjI1) (* q ∧ r ⟹ (p ∨ q) ∧ (p ∨ r) *)
apply (erule conjE) (* ⟦q; r⟧ ⟹ (p ∨ q) ∧ (p ∨ r) *)
apply (rule conjI) (* ⟦q; r⟧ ⟹ p ∨ q
⟦q; r⟧ ⟹ p ∨ r *)
apply (erule disjI2) (* ⟦q; r⟧ ⟹ p ∨ r *)
apply (erule disjI2) (* *)
done

lemma ej35b: "p ∨ (q ∧ r) ⟹ (p ∨ q) ∧ (p ∨ r)"
apply (rule conjI) (* p ∨ (q ∧ r) ⟹ p ∨ q
p ∨ (q ∧ r) ⟹ p ∨ r *)
apply (erule disjE) (* p ⟹ p ∨ q
q ∧ r ⟹ p ∨ q
p ∨ (q ∧ r) ⟹ p ∨ r *)
apply (erule disjI1) (* q ∧ r ⟹ p ∨ q
p ∨ (q ∧ r) ⟹ p ∨ r *)
apply (drule conjunct1) (* q ⟹ p ∨ q
p ∨ (q ∧ r) ⟹ p ∨ r *)
apply (erule disjI2) (* p ∨ (q ∧ r) ⟹ p ∨ r *)
apply (erule disjE) (* p ⟹ p ∨ r
q ∧ r ⟹ p ∨ r *)
apply (erule disjI1) (* q ∧ r ⟹ p ∨ r *)
apply (drule conjunct2) (* r ⟹ p ∨ r *)
apply (erule disjI2) (* *)
done

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

lemma ej36a: "(p ∨ q) ∧ (p ∨ r) ⟹ p ∨ (q ∧ r)"
apply (erule conjE) (* ⟦p ∨ q; p ∨ r⟧ ⟹ p ∨ (q ∧ r) *)
apply (erule disjE) (* ⟦p ∨ r; p⟧ ⟹ p ∨ (q ∧ r)
⟦p ∨ r; q⟧ ⟹ p ∨ (q ∧ r) *)
apply (erule disjI1) (* ⟦p ∨ r; q⟧ ⟹ p ∨ (q ∧ r) *)
apply (erule disjE) (* ⟦q; p⟧ ⟹ p ∨ (q ∧ r)
⟦q; r⟧ ⟹ p ∨ (q ∧ r) *)
apply (erule disjI1) (* ⟦q; r⟧ ⟹ p ∨ (q ∧ r) *)
apply (rule disjI2) (* ⟦q; r⟧ ⟹ q ∧ r *)
apply (rule conjI) (* ⟦q; r⟧ ⟹ q
⟦q; r⟧ ⟹ r *)
apply assumption (* ⟦q; r⟧ ⟹ r *)
apply assumption (* *)
done

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

lemma ej37a: "(p ⟶ r) ∧ (q ⟶ r) ⟹ p ∨ q ⟶ r"
apply (rule impI) (* ⟦(p ⟶ r) ∧ (q ⟶ r); p ∨ q⟧ ⟹ r *)
apply (erule conjE) (* ⟦p ∨ q; p ⟶ r; q ⟶ r⟧ ⟹ r *)
apply (erule disjE) (* ⟦p ⟶ r; q ⟶ r; p⟧ ⟹ r
⟦p ⟶ r; q ⟶ r; q⟧ ⟹ r *)
apply (erule mp) (* ⟦q ⟶ r; p⟧ ⟹ p
⟦p ⟶ r; q ⟶ r; q⟧ ⟹ r *)
apply assumption (* ⟦p ⟶ r; q ⟶ r; q⟧ ⟹ r *)
apply (erule_tac P=q in mp) (* ⟦p ⟶ r; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej37b: "(p ⟶ r) ∧ (q ⟶ r) ⟹ p ∨ q ⟶ r"
apply (rule impI) (* (p ⟶ r) ∧ (q ⟶ r) ⟹ p ∨ q ⟹ r *)
apply (erule conjE) (* ⟦p ∨ q; p ⟶ r; q ⟶ r⟧ ⟹ r *)
apply (erule disjE) (* ⟦p ⟶ r; q ⟶ r; p⟧ ⟹ r
⟦p ⟶ r; q ⟶ r; q⟧ ⟹ r *)
apply (erule mp,
assumption+)+ (* *)
done

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

lemma ej38a: "p ∨ q ⟶ r ⟹ (p ⟶ r) ∧ (q ⟶ r)"
apply (rule conjI) (* p ∨ q ⟶ r ⟹ p ⟶ r
p ∨ q ⟶ r ⟹ q ⟶ r *)
apply (rule impI) (* ⟦p ∨ q ⟶ r; p⟧ ⟹ r
p ∨ q ⟶ r ⟹ q ⟶ r *)
apply (erule mp) (* p ⟹ p ∨ q
p ∨ q ⟶ r ⟹ q ⟶ r *)
apply (erule disjI1) (* p ∨ q ⟶ r ⟹ q ⟶ r *)
apply (rule impI) (* ⟦p ∨ q ⟶ r; q⟧ ⟹ r *)
apply (erule mp) (* q ⟹ p ∨ q *)
apply (erule disjI2) (* *)
done

section {* Negación *}

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

lemma ej39: "p ⟹ ¬¬p"
apply (rule notI) (* ⟦p; ¬ p⟧ ⟹ False *)
apply (erule notE) (* p ⟹ p *)
apply assumption (* *)
done

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

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

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

lemma ej41: "p ⟶ q ⟹ ¬q ⟶ ¬p"
apply (rule impI) (* ⟦p ⟶ q; ¬ q⟧ ⟹ ¬ p *)
apply (rule notI) (* ⟦p ⟶ q; ¬ q; p⟧ ⟹ False *)
apply (drule mp) (* ⟦¬ q; p⟧ ⟹ p
⟦¬ q; p; q⟧ ⟹ False *)
apply assumption (* ⟦¬ q; p; q⟧ ⟹ False *)
apply (erule notE) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

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

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

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

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

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

lemma ej44a: "p ∨ q ⟹ ¬(¬p ∧ ¬q)"
apply (rule notI) (* ⟦p ∨ q; ¬ p ∧ ¬ q⟧ ⟹ False *)
apply (erule conjE) (* ⟦p ∨ q; ¬ p; ¬ q⟧ ⟹ False *)
apply (erule disjE) (* ⟦¬ p; ¬ q; p⟧ ⟹ False
⟦¬ p; ¬ q; q⟧ ⟹ False *)
apply (erule notE) (* ⟦¬ q; p⟧ ⟹ p
⟦¬ p; ¬ q; q⟧ ⟹ False *)
apply assumption (* ⟦¬ p; ¬ q; q⟧ ⟹ False *)
apply (erule_tac P=q in notE) (* ⟦¬ p; q⟧ ⟹ q *)
apply assumption (* *)
done

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

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

lemma ej45a: "p ∧ q ⟹ ¬(¬p ∨ ¬q)"
apply (rule notI) (* ⟦p ∧ q; ¬ p ∨ ¬ q⟧ ⟹ False *)
apply (erule conjE) (* ⟦¬ p ∨ ¬ q; p; q⟧ ⟹ False *)
apply (erule disjE) (* ⟦p; q; ¬ p⟧ ⟹ False
⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE) (* ⟦p; q⟧ ⟹ p
⟦p; q; ¬ q⟧ ⟹ False *)
apply assumption (* ⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE) (* ⟦p; q⟧ ⟹ q *)
apply assumption (* *)
done

lemma ej45b: "p ∧ q ⟹ ¬(¬p ∨ ¬q)"
apply (rule notI) (* ⟦p ∧ q; ¬ p ∨ ¬ q⟧ ⟹ False *)
apply (erule conjE) (* ⟦¬ p ∨ ¬ q; p; q⟧ ⟹ False *)
apply (erule disjE) (* ⟦p; q; ¬ p⟧ ⟹ False
⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE,
assumption) (* ⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE,
assumption) (* *)
done

lemma ej45c: "p ∧ q ⟹ ¬(¬p ∨ ¬q)"
apply (rule notI) (* ⟦p ∧ q; ¬ p ∨ ¬ q⟧ ⟹ False *)
apply (erule conjE) (* ⟦¬ p ∨ ¬ q; p; q⟧ ⟹ False *)
apply (erule disjE) (* ⟦p; q; ¬ p⟧ ⟹ False
⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE,
assumption)+ (* *)
done

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

lemma ej46b: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
apply (rule conjI) (* ¬ (p ∨ q) ⟹ ¬ p
¬ (p ∨ q) ⟹ ¬ q *)
apply (rule notI) (* ⟦¬ (p ∨ q); p⟧ ⟹ False
¬ (p ∨ q) ⟹ ¬ q *)
apply (erule notE) (* p ⟹ p ∨ q
¬ (p ∨ q) ⟹ ¬ q *)
apply (erule disjI1) (* ¬ (p ∨ q) ⟹ ¬ q *)
apply (rule notI) (* ⟦¬ (p ∨ q); q⟧ ⟹ False *)
apply (erule notE) (* q ⟹ p ∨ q *)
apply (erule disjI2) (* *)
done

lemma ej46b: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
apply (rule conjI) (* ¬ (p ∨ q) ⟹ ¬ p
¬ (p ∨ q) ⟹ ¬ q *)
apply (rule notI,
erule notE,
(erule disjI1 |
erule disjI2))+ (* *)
done

lemma ej46c: "¬(p ∨ q) ⟹ ¬p ∧ ¬q"
by (rule conjI,
(rule notI,
erule notE,
(erule disjI1 |
erule disjI2))+)

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

lemma ej47a: "¬p ∧ ¬q ⟹ ¬(p ∨ q)"
apply (rule notI) (* ⟦¬ p ∧ ¬ q; p ∨ q⟧ ⟹ False *)
apply (erule disjE) (* ⟦¬ p ∧ ¬ q; p⟧ ⟹ False
⟦¬ p ∧ ¬ q; q⟧ ⟹ False *)
apply (drule conjunct1) (* ⟦p; ¬ p⟧ ⟹ False
⟦¬ p ∧ ¬ q; q⟧ ⟹ False *)
apply (erule notE) (* p ⟹ p
⟦¬ p ∧ ¬ q; q⟧ ⟹ False *)
apply assumption (* ⟦¬ p ∧ ¬ q; q⟧ ⟹ False*)
apply (drule conjunct2) (* ⟦q; ¬ q⟧ ⟹ False *)
apply (erule notE) (* q ⟹ q *)
apply assumption (* *)

lemma ej47b: "¬p ∧ ¬q ⟹ ¬(p ∨ q)"
apply (rule notI) (* ⟦¬ p ∧ ¬ q; p ∨ q⟧ ⟹ False *)
apply (erule disjE) (* ⟦¬ p ∧ ¬ q; p⟧ ⟹ False
⟦¬ p ∧ ¬ q; q⟧ ⟹ False *)
apply ((drule conjunct1 |
drule conjunct2),
erule notE,
assumption)+ (* *)

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

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

lemma ej48a: "¬p ∨ ¬q ⟹ ¬(p ∧ q)"
apply (rule notI) (* ⟦¬ p ∨ ¬ q; p ∧ q⟧ ⟹ False *)
apply (erule disjE) (* ⟦p ∧ q; ¬ p⟧ ⟹ False
⟦p ∧ q; ¬ q⟧ ⟹ False *)
apply (drule conjunct1) (* ⟦¬ p; p⟧ ⟹ False
⟦p ∧ q; ¬ q⟧ ⟹ False *)
apply (erule notE) (* p ⟹ p
⟦p ∧ q; ¬ q⟧ ⟹ False *)
apply assumption (* ⟦p ∧ q; ¬ q⟧ ⟹ False *)
apply (drule conjunct2) (* ⟦¬ q; q⟧ ⟹ False *)
apply (erule notE) (* q ⟹ q *)
apply assumption (* *)
done

lemma ej48b: "¬p ∨ ¬q ⟹ ¬(p ∧ q)"
apply (rule notI) (* ⟦¬ p ∨ ¬ q; p ∧ q⟧ ⟹ False *)
apply (erule conjE) (* ⟦¬ p ∨ ¬ q; p; q⟧ ⟹ False *)
apply (erule disjE) (* ⟦p; q; ¬ p⟧ ⟹ False
⟦p; q; ¬ q⟧ ⟹ False *)
apply (erule notE,
assumption)+ (* *)
done

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

lemma ej49: "¬(p ∧ ¬p)"
apply (rule notI) (* p ∧ ¬ p ⟹ False *)
apply (erule conjE) (* ⟦p; ¬ p⟧ ⟹ False *)
apply (erule notE) (* ⟦p; ¬ p⟧ ⟹ False *)
apply assumption (* *)
done

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

lemma ej50: "p ∧ ¬p ⟹ q"
apply (erule conjE) (* ⟦p; ¬ p⟧ ⟹ q *)
apply (erule notE) (* p ⟹ p *)
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) (* ¬¬p ∨ ¬p ⟹ p ∨ ¬p*)
apply (erule disjE) (* ¬ ¬ p ⟹ p ∨ ¬ p
¬ p ⟹ p ∨ ¬ p *)
apply (rule disjI1) (* ¬ ¬ p ⟹ p
¬ p ⟹ p ∨ ¬ p *)
apply (erule notnotD) (* ¬ p ⟹ p ∨ ¬ p *)
apply (erule disjI2) (* *)
done

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

lemma ej53: "((p ⟶ q) ⟶ p) ⟶ p"
apply (cut_tac P="p ⟶ q" in excluded_middle)
(* ¬ (p ⟶ q) ∨ (p ⟶ q) ⟹
((p ⟶ q) ⟶ p) ⟶ p *)
apply (erule disjE) (* ¬ (p ⟶ q) ⟹ ((p ⟶ q) ⟶ p) ⟶ p
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (rule impI) (* ⟦¬ (p ⟶ q); (p ⟶ q) ⟶ p⟧ ⟹ p
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (rule ccontr) (* ⟦¬ (p ⟶ q); (p ⟶ q) ⟶ p; ¬ p⟧ ⟹ False
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (erule_tac P="p ⟶ q" in notE)
(* ⟦(p ⟶ q) ⟶ p; ¬ p⟧ ⟹ p ⟶ q
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (rule impI) (* ⟦(p ⟶ q) ⟶ p; ¬ p; p⟧ ⟹ q
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (erule notE) (* ⟦(p ⟶ q) ⟶ p; p⟧ ⟹ p
p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply assumption (* p ⟶ q ⟹ ((p ⟶ q) ⟶ p) ⟶ p *)
apply (rule impI) (* ⟦p ⟶ q; (p ⟶ q) ⟶ p⟧ ⟹ p *)
apply (erule_tac P="p ⟶q" in mp)
(* p ⟶ q ⟹ p ⟶ q *)
apply assumption (* *)

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

lemma ej54: "¬q ⟶ ¬p ⟹ p ⟶ q"
apply (rule impI) (* ⟦¬ q ⟶ ¬ p; p⟧ ⟹ q *)
apply (rule notnotD) (* ⟦¬ q ⟶ ¬ p; p⟧ ⟹ ¬ ¬ q *)
apply (erule mt) (* p ⟹ ¬ ¬ p *)
apply (erule notnotI) (* *)
done

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

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

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

lemma ej56a: "¬(¬p ∨ ¬q) ⟹ p ∧ q"
apply (rule conjI) (* ¬ (¬ p ∨ ¬ q) ⟹ p
¬ (¬ p ∨ ¬ q) ⟹ q *)
apply (rule ccontr) (* ⟦¬ (¬ p ∨ ¬ q); ¬ p⟧ ⟹ False
¬ (¬ p ∨ ¬ q) ⟹ q *)
apply (erule notE) (* ¬ p ⟹ ¬ p ∨ ¬ q
¬ (¬ p ∨ ¬ q) ⟹ q *)
apply (erule disjI1) (* ¬ (¬ p ∨ ¬ q) ⟹ q *)
apply (rule ccontr) (* ⟦¬ (¬ p ∨ ¬ q); ¬ q⟧ ⟹ False *)
apply (erule notE) (* ¬ q ⟹ ¬ p ∨ ¬ q *)
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)
(* ⟦¬ (p ∧ q); ¬ p ∨ p⟧ ⟹ ¬ p ∨ ¬ q *)
apply (erule disjE) (* ⟦¬ (p ∧ q); ¬ p⟧ ⟹ ¬ p ∨ ¬ q
⟦¬ (p ∧ q); p⟧ ⟹ ¬ p ∨ ¬ q *)
apply (erule disjI1) (* ⟦¬ (p ∧ q); p⟧ ⟹ ¬ p ∨ ¬ q *)
apply (cut_tac P=q in excluded_middle)
(* ⟦¬ (p ∧ q); p; ¬ q ∨ q⟧ ⟹ ¬ p ∨ ¬ q *)
apply (erule disjE) (* ⟦¬ (p ∧ q); p; ¬ q⟧ ⟹ ¬ p ∨ ¬ q
⟦¬ (p ∧ q); p; q⟧ ⟹ ¬ p ∨ ¬ q *)
apply (erule disjI2) (* ⟦¬ (p ∧ q); p; q⟧ ⟹ ¬ p ∨ ¬ q *)
apply (erule notE) (* ⟦p; q⟧ ⟹ p ∧ q *)
apply (rule conjI) (* ⟦p; q⟧ ⟹ p
⟦p; q⟧ ⟹ q *)
apply assumption+ (* *)
done

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

lemma ej58a: "(p ⟶ q) ∨ (q ⟶ p)"
apply (cut_tac P=p in excluded_middle)
(* ¬ p ∨ p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule disjE) (* ¬ p ⟹ (p ⟶ q) ∨ (q ⟶ p)
p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule disjI1) (* ¬ p ⟹ p ⟶ q
p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule impI) (* ⟦¬ p; p⟧ ⟹ q
p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule notE) (* p ⟹ p
p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply assumption (* p ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule disjI2) (* p ⟹ q ⟶ p *)
apply (rule impI) (* ⟦p; q⟧ ⟹ p *)
apply assumption (* *)
done

lemma ej58b: "(p ⟶ q) ∨ (q ⟶ p)"
apply (cut_tac P="p ⟶ q" in excluded_middle)
(* ¬ (p ⟶ q) ∨ (p ⟶ q) ⟹
(p ⟶ q) ∨ (q ⟶ p) *)
apply (erule disjE) (* ¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p)
p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule disjI2) (* ¬ (p ⟶ q) ⟹ q ⟶ p
p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule impI) (* ⟦¬ (p ⟶ q); q⟧ ⟹ p
p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule notE) (* q ⟹ p ⟶ q
p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule impI) (* ⟦q; p⟧ ⟹ q
p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply assumption (* p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule disjI1) (* *)
done

lemma ej58c: "(p ⟶ q) ∨ (q ⟶ p)"
apply (cut_tac P="¬(p ⟶ q)" in excluded_middle)
(* ¬ ¬ (p ⟶ q) ∨ ¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule disjE) (* ¬ ¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p)
¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (drule notnotD) (* p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p)
¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (erule disjI1) (* ¬ (p ⟶ q) ⟹ (p ⟶ q) ∨ (q ⟶ p) *)
apply (rule disjI2) (* ¬ (p ⟶ q) ⟹ q ⟶ p *)
apply (rule impI) (* ⟦¬ (p ⟶ q); q⟧ ⟹ p *)
apply (erule notE) (* q ⟹ p ⟶ q *)
apply (rule impI) (* ⟦q; p⟧ ⟹ q *)
apply assumption (* *)
done

end
</source>

Relación 3

2019-04-11T14:44:16Z

Jalonso:

=== Relación 3: Deducción natural en lógica proposicional ===

----
'''Ejercicio 1.''' Demostrar mediante deducción natural:
: {p → r, r → ¬ q} ⊧ ¬(p ∧ q)
----

'''Solución:''' sofsanfer, luiporpir, paurinara

[[Archivo:ej1rel3.png]]

migtromol, nurgomvar, matcarcar, roccorcor

[[Archivo:Ejercicio3.1.PNG]]

----
'''Ejercicio 2.''' Demostrar mediante deducción natural:
: ¬p ∧ ¬q ⊧ ¬(p ∨ q)
----

'''Solución:''' sofsanfer, migtromol, luiporpir, nurgomvar, matcarcar, paurinara, roccorcor

[[Archivo:ej2rel3.png]]

----
'''Ejercicio 3.''' Demostrar mediante deducción natural:
: p ∨ q ⊧ ¬(¬ p ∧ ¬ q )
----

'''Solución:''' sofsanfer, migtromol, luiporpir, nurgomvar, matcarcar, paurinara, roccorcor

[[Archivo:ej3rel3.png]]

----
'''Ejercicio 4.''' Demostrar mediante deducción natural:
: ¬ p ∨ ¬ q ⊧ ¬( p ∧ q )
----

'''Solución:''' sofsanfer, migtromol, luiporpir, nurgomvar, matcarcar, paurinara, roccorcor

[[Archivo:ej4rel3.png]]

----
'''Ejercicio 5.''' Demostrar mediante deducción natural:
: {p → r, r → ¬ q} ⊧ ¬(p ∧ q)
----

'''Solución:''' sofsanfer, migtromol, luiporpir, nurgomvar, paurinara, roccorcor

[[Archivo:ej5rel3.png]]

----
'''Ejercicio 6.''' Demostrar mediante deducción natural:
: ⊧ ((p → q) → p)
----

'''Solución:''' luiporpir, sofsanfer

[[Archivo:ej6_rel3.jpg]]

----
'''Ejercicio 7.''' Demostrar mediante deducción natural:
: (p → q) ∨ (q → p)
----

'''Solución:'''

josgutde3

Usaremos dos lemas en la demostración:
: '''Lema 1.''' ¬(F → G) ⊧ F ∧ ¬G
: [[Archivo:lema_1.jpg]]
: '''Ley de De Morgan.''' ¬(F ∨ G) ⊧ ¬F ∧ ¬G
: [[Archivo:lema_2.jpg]]

: Ahora podemos demostrar que ⊧(p → q) ∨ (q → p)
: [[Archivo:ej7rel3_2.jpg]]

sofsanfer

[[Archivo:ej7rel3sofsanfer.png]]

----
'''Ejercicio 8.''' Demostrar mediante deducción natural:
: p → (q ∧ r) ⊧ (p → q) ∨ (p → r)
----

'''Solución:''' Antmorlop8, luiporpir, nurgomvar, sofsanfer

[[Archivo:ejercicio8.jpg]

Página principal

2019-04-11T14:41:59Z

Jalonso:

Este sitio contiene materiales del curso [https://www.cs.us.es/~jalonso/cursos/lmf/temas.php '''Lógica matemática y fundamentos'''] de 3º del [http://www.us.es/estudios/grados/plan_171?p=7 Grado en Matemáticas] de la [http://www.us.es Universidad de Sevilla].

== Material para el curso ==
* [[Temas]]: Transparencias de los temas y teorías.
* [[Ejercicios]]: Relaciones de ejercicios.

Deducción natural en lógica de primer orden con Isabelle/HOL basada en tácticas

2019-04-01T12:27:38Z

Jalonso:

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

section "Introducción"

subsection "Reglas de primer orden en Isabelle/HOL"

thm spec [no_vars]
(* da ∀x. P x ⟹ P x *)

thm allE [no_vars]
(* da ⟦∀x. P x; P x ⟹ R⟧ ⟹ R *)

thm allI [no_vars]
(* da (⋀x. P x) ⟹ ∀x. P x *)

thm exI
(* da ?P ?x ⟹ ∃x. ?P x *)

thm exE [no_vars]
(* da ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q *)

subsection "Ejemplos de demostraciones"

text {* Ejemplo con spec y exI*}
lemma "∀x. P x ⟹ ∃y. P y"
apply (drule_tac x=a in spec) (* da P a ⟹ ∃y. P y *)
apply (rule_tac x=a in exI) (* da P a ⟹ P a *)
apply assumption (* da No subgoals!*)
done

text {* Explicaciones:
apply (drule_tac x=a in spec)
+ Objetivo: "∀x. P x ⟹ ∃y. P y"
+ spec: "∀x. ?P x ⟹ ?P ?x"
+ spec "x=a": "∀x. ?P x ⟹ ?P a"
+ Unificador de "∀x. P x" con
"∀x. ?P x"
es ?P/P
+ Nuevo objetivo: "P a ⟹ ∃y. P y"

apply (rule_tac x=a in exI)
+ Objetivo: "P a ⟹ ∃y. P y"
+ exI: "?P ?x ⟹ ∃x. ?P x"
+ exI "x=a": "?P a ⟹ ∃x. ?P x"
+ Unificador de "∃y. P y" con
"∃x. ?P x"
es ?P/P
+ Nuevo objetivo: "P a ⟹ P a"
*}

text {* Ejemplo con spec y exI*}
lemma "∀x. P x ⟹ ∃x. P x"
apply (rule exI) (* da ∀x. P x ⟹ P ?x *)
apply (erule spec) (* da No subgoals! *)
done

text {* Explicaciones
apply (rule exI)
+ Objetivo: "∀x. P x ⟹ ∃x. P x"
+ exI: "?P ?x ⟹ ∃x. ?P x"
+ Unificador de "∃x. P x" y
"∃x. ?P x"
es ?P/P
+ Nuevo objetivo: "∀x. P x ⟹ P ?x"

apply (erule spec)
+ Objetivo: "∀x. P x ⟹ P ?x"
+ spec: "∀x. ?P x ⟹ ?P ?x"
+ Unificador de ("?P ?x", "∀x. P x") y
("?P ?x", "∀x. ?P x"
es ?P/P
+ Nuevo objetivo: Vacío, porque erule aplica assumption a
"P ?x ⟹ P ?x"
*}

text {* Ejemplo con allE y exI*}
lemma "∀x. P x ⟹ ∃x. P x"
apply (erule allE) (* da P ?x ⟹ ∃x. P x*)
apply (erule exI) (* da No subgoals! *)
done

text {* Explicaciones
apply (erule allE)
+ Objetivo: "∀x. P x ⟹ ∃x. P x"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("?R", "∀x. ?P x") y
("∃x. P x", "∀x. P x")
es ?R / ∃x. P x
?P / P
+ Nuevo objetivo: "P ?x ⟹ ∃x. P x"

apply (erule exI)
+ Objetivo: "P ?x ⟹ ∃x. P x"
+ exI: "?P ?x ⟹ ∃x. ?P x"
+ Unificador de ("∃x. P x", "P ?x") y
("∃x. ?P x", "?P ?x")
es ?P / P
?x / x
+ Nuevo objetivo: Vacío
*}

text {* Ejemplo con erule_tac *}
lemma "⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ ∀z. Q z"
apply (rule allI) (* da ⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧
⟹ Q z *)
apply (erule_tac x=z in allE) (* da ⋀z. ⟦∀y. P y; P z ⟶ Q z⟧
⟹ Q z *)
apply (erule_tac x=z in allE) (* da ⋀z. ⟦P z ⟶ Q z; P z⟧ ⟹ Q z *)
apply (erule impE) (* da ⋀z. P z ⟹ P z
⋀z. ⟦P z; Q z⟧ ⟹ Q z *)
apply assumption+ (* da No subgoals! *)
done

thm impE

text {* Explicaciones
apply (rule allI)
+ Objetivo: "⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ ∀z. Q z"
+ allI: "(⋀x. ?P x) ⟹ ∀x. ?P x"
+ Unificador de "∀z. Q z" y
"∀x. ?P x"
es ?P / Q
+ Ligadura: ⋀x / ⋀z
+ Nuevo objetivo: "⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ Q z"

apply (erule_tac x=z in allE)
+ Objetivo: "⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ Q z"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ allE "x=z" "⟦∀x. ?P x; ?P z ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q z", "∀x. P x ⟶ Q x") y
("?R", "∀x. ?P x")
es ?R / Q z
?P x / P x ⟶ Q x
+ Nuevo objetivo: "⋀z. ⟦∀y. P y; P z ⟶ Q z⟧ ⟹ Q z"
+ Nota: De "?P z ⟹ ?R" se obtiene la 2ª hipótesis y la conclusión.

apply (erule_tac x=z in allE)
+ Objetivo: "⋀z. ⟦∀y. P y; P z ⟶ Q z⟧ ⟹ Q z"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ allE "x=z" "⟦∀x. ?P x; ?P z ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q z", "∀y. P y") y
("?R", "∀x. ?P x")
es ?R / Q z
?P / P
+ Nuevo objetivo: "⋀z. ⟦P z ⟶ Q z; P z⟧ ⟹ Q z"
+ Nota: De "?P z ⟹ ?R" se obtiene la 2ª hipótesis y la conclusión.

apply (erule impE)
+ Objetivo: "⋀z. ⟦P z ⟶ Q z; P z⟧ ⟹ Q z"
+ impE "⟦?P ⟶ ?Q; ?P; ?Q ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q z", "P z ⟶ Q z") y
("?R", "?P ⟶ ?Q")
es ?R / Q z
?P / P z
?Q /Q z
+ Nuevos objetivos: "⋀z. P z ⟹ P z"
"⋀z. ⟦P z; Q z⟧ ⟹ Q z"
*}

text {* Ejemplo sin erule_tac *}
lemma "⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ ∀z. Q z"
apply (rule allI) (* da ⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ Q z *)
apply (erule allE) (* da ⋀z. ⟦∀y. P y; P (?x2 z) ⟶ Q (?x2 z)⟧
⟹ Q z *)
apply (erule allE) (* da ⋀z. ⟦P (?x2 z) ⟶ Q (?x2 z); P (?y4 z)⟧
⟹ Q z *)
apply (erule mp) (* da ⋀z. P (?y4 z) ⟹ P z *)
apply assumption (* da No subgoals *)
done

text {*
apply (rule allI)
+ Objetivo: "⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ ∀z. Q z"
+ allI: "(⋀x. ?P x) ⟹ ∀x. ?P x"
+ Unificador de "∀z. Q z" y
"∀x. ?P x"
es ?P / Q
+ Ligadura: ⋀x / ⋀z
+ Nuevo objetivo: "⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ Q z"

apply (erule allE)
+ Objetivo: "⋀z. ⟦∀x. P x ⟶ Q x; ∀y. P y⟧ ⟹ Q z"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q z", "∀x. P x ⟶ Q x") y
("?R", "∀x. ?P x")
es ?R / Q z
?P x / P x ⟶ Q x
+ Nuevo objetivo: "⋀z. ⟦∀y. P y; P (?x2 z) ⟶ Q (?x2 z)⟧ ⟹ Q z"

apply (erule allE)
+ Objetivo: "⋀z. ⟦∀y. P y; P (?x2 z) ⟶ Q (?x2 z)⟧ ⟹ Q z"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q z", "∀y. P y") y
("?R", "∀x. ?P x")
es ?R / Q z
?P / P
+ Nuevo objetivo: "⋀z. ⟦P (?x2 z) ⟶ Q (?x2 z); P (?y4 z)⟧ ⟹ Q z"

apply (erule mp)
+ Objetivo: "⋀z. ⟦P (?x2 z) ⟶ Q (?x2 z); P (?y4 z)⟧ ⟹ Q z"
+ mp: "⟦?P ⟶ ?Q; ?P⟧ ⟹ ?Q"
+ Unificador de ("Q z", "P (?x2 z) ⟶ Q (?x2 z)") y
("?Q", "?P ⟶ ?Q")
es ?Q / Q z
?x2 z/ z
?P / P z
+ Nuevo objetivo: "⋀z. P (?y4 z) ⟹ P z"
*}

text {* Ejemplo con exE *}
lemma "(∃z. P z) ∧ Q ⟶ (∃y. P y ∧ Q)"
apply (rule impI) (* da (∃z. P z) ∧ Q ⟹ ∃y. P y ∧ Q *)
apply (erule conjE) (* da ⟦∃z. P z; Q⟧ ⟹ ∃y. P y ∧ Q *)
apply (erule exE) (* da ⋀z. ⟦Q; P z⟧ ⟹ ∃y. P y ∧ Q *)
apply (rule_tac x="z" in exI) (* da ⋀z. ⟦Q; P z⟧ ⟹ P z ∧ Q *)
apply (rule conjI) (* da ⋀z. ⟦Q; P z⟧ ⟹ P z
⋀z. ⟦Q; P z⟧ ⟹ Q *)
apply assumption+ (* da No subgoals! *)
done

text {* Explicaciones:
apply (rule impI)
+ Objetivo: "(∃z. P z) ∧ Q ⟶ (∃y. P y ∧ Q)"
+ impI: "(?P ⟹ ?Q) ⟹ ?P ⟶ ?Q"
+ Unificador de "(∃z. P z) ∧ Q ⟶ (∃y. P y ∧ Q)" y
"?P ⟶ ?Q"
es ?P / "(∃z. P z) ∧ Q"
?Q / "∃y. P y ∧ Q"
+ Nuevo objetivo: "(∃z. P z) ∧ Q ⟹ ∃y. P y ∧ Q"

apply (erule conjE)
+ Objetivo: "(∃z. P z) ∧ Q ⟹ ∃y. P y ∧ Q"
+ conjE: "⟦?P ∧ ?Q; ⟦?P; ?Q⟧ ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("∃y. P y ∧ Q", "(∃z. P z) ∧ Q") y
("?R", "?P ∧ ?Q")
es ?R / "∃y. P y ∧ Q"
?P / "∃z. P z"
?Q / Q
+ Nuevo objetivo: "⟦∃z. P z; Q⟧ ⟹ ∃y. P y ∧ Q"

apply (erule exE)
+ Objetivo: "⟦∃z. P z; Q⟧ ⟹ ∃y. P y ∧ Q"
+ exE: "⟦∃x. ?P x; ⋀x. ?P x ⟹ ?Q⟧ ⟹ ?Q"
+ Unificador de ("∃y. P y ∧ Q", "∃z. P z") y
("?Q", "∃x. ?P x")
es ?Q / "∃y. P y ∧ Q"
?P x / P z
+ Nuevo objetivo: "⋀z. ⟦Q; P z⟧ ⟹ ∃y. P y ∧ Q"

apply (rule_tac x="z" in exI)
+ Objetivo: "⋀z. ⟦Q; P z⟧ ⟹ ∃y. P y ∧ Q"
+ exI: "?P ?x ⟹ ∃x. ?P x"
+ exI "x=z" "?P z ⟹ ∃x. ?P x"
+ Unificador de "∃y. P y ∧ Q" con
"∃x. ?P x"
es ?P x / P x ∧ Q
+ Nuevo objetivo: "⋀z. ⟦Q; P z⟧ ⟹ P z ∧ Q"

apply (rule conjI)
+ Objetivo: "⋀z. ⟦Q; P z⟧ ⟹ P z ∧ Q"
+ conjI: "⟦?P; ?Q⟧ ⟹ ?P ∧ ?Q"
+ Unificador de "P z ∧ Q" con
"?P ∧ ?Q"
es ?P / P z
?Q / Q
+ Nuevos objetivos: "⋀z. ⟦Q; P z⟧ ⟹ P z"
"⋀z. ⟦Q; P z⟧ ⟹ Q"
*}

subsection "Cálculo de secuentes de primer orden"

lemma "A ⟹ ∀x. P x"
apply (rule allI) (* da ⋀x. A ⟹ P x *)
oops

text {* Explicación
+ Objetivo: "A ⟹ ∀x. P x"
+ allI: "(⋀x. ?P x) ⟹ ∀x. ?P x"
+ Unificador de "∀x. P x" y
"∀x. ?P x"
es ?P / P
+ Nuevo objetivo: "⋀x. A ⟹ P x"
*}

lemma "⟦A; ∀x. P x⟧ ⟹ Q"
apply (erule allE) (* da ⟦A; P ?x⟧ ⟹ Q *)
oops

text {* Explicación
+ Objetivo: "⟦A; ∀x. P x⟧ ⟹ Q"
+ allI: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q", "∀x. P x") y
("?R·, "∀x. ?P x)"
es ?R / Q
?P / P
+ Nuevo objetivo: "⟦A; P ?x⟧ ⟹ Q"
*}

lemma "⟦A; ∀x. P x⟧ ⟹ Q"
apply (erule_tac x=t in allE) (* da ⟦A; P t⟧ ⟹ Q *)
oops

text {* Explicación
+ Objetivo: "⟦A; ∀x. P x⟧ ⟹ Q"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ allE "x=t" "⟦∀x. ?P x; ?P t ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("Q", "∀x. P x") y
("?R·, "∀x. ?P x)"
es ?R / Q
?P / P
+ Nuevo objetivo: "⟦A; P ?t⟧ ⟹ Q"
*}

lemma "⟦A; ∀x. P x⟧ ⟹ Q"
apply (frule spec) (* da ⟦A; ∀x. P x; P ?x⟧ ⟹ Q *)
oops

text {* Explicación
+ Objetivo: "⟦A; ∀x. P x⟧ ⟹ Q"
+ spec: "∀x. ?P x ⟹ ?P ?x"
+ Unificador de "∀x. P x" y
"∀x. ?P x"
es ?P / P
+ Nuevo objetivo: "⟦A; ∀x. P x; P ?x⟧ ⟹ Q"
*}

lemma "⟦A; ∀x. P x⟧ ⟹ Q"
apply (frule_tac x=t in spec) (* da ⟦A; ∀x. P x; P t⟧ ⟹ Q *)
oops

text {* Explicación
+ Objetivo: "⟦A; ∀x. P x⟧ ⟹ Q"
+ spec: "∀x. ?P x ⟹ ?P ?x"
+ spec "x=t" "∀x. ?P x ⟹ ?P t"
+ Unificador de "∀x. P x" y
"∀x. ?P x"
es ?P / P
+ Nuevo objetivo: "⟦A; ∀x. P x; P t⟧ ⟹ Q"
*}

lemma "A ⟹ ∃x. P x"
apply (rule exI) (* da A ⟹ P ?x *)
oops

text {* Explicación
+ Objetivo: "A ⟹ ∃x. P x"
+ spec: "?P ?x ⟹ ∃x. ?P x"
+ Unificador de "∃x. P x" y
"∃x. ?P x"
es ?P / P
+ Nuevo objetivo: "A ⟹ P ?x"
*}

lemma "A ⟹ ∃x. P x"
apply (rule_tac x=t in exI) (* da A ⟹ P t *)
oops

text {* Explicación
+ Objetivo: "A ⟹ ∃x. P x"
+ spec: "?P ?x ⟹ ∃x. ?P x"
+ spec "x=t": "?P t ⟹ ∃x. ?P x"
+ Unificador de "∃x. P x" y
"∃x. ?P x"
es ?P / P
+ Nuevo objetivo: "A ⟹ P t"
*}

lemma "⟦A; ∃x. P x⟧ ⟹ Q"
apply (erule exE) (* da ⋀x. ⟦A; P x⟧ ⟹ Q *)
oops

text {* Explicación
+ Objetivo: "⟦A; ∃x. P x⟧ ⟹ Q"
+ exE: "⟦∃x. ?P x; ⋀x. ?P x ⟹ ?Q⟧ ⟹ ?Q"
+ Unificador de ("Q", "∃x. P x" y
("?Q", "∃x. ?P x"
es ?Q / Q
?P / P
+ Nuevo objetivo: "⋀x. ⟦A; P x⟧ ⟹ Q"
*}

section "Ejemplos del tema 6"

subsection {* Reglas del cuantificador universal *}

lemma ej1: "⟦P(c); ∀x. (P(x) ⟶ ¬Q(x))⟧ ⟹ ¬Q(c)"
apply (erule allE) (* da ⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c *)
apply (erule mp) (* da P c ⟹ P c *)
apply assumption (* da No subgoals! *)
done

text {* Explicaciones
apply (erule allE)
+ Objetivo: "⟦P(c); ∀x. (P(x) ⟶ ¬Q(x))⟧ ⟹ ¬Q(c)"
+ allE: "⟦∀x. ?P x; ?P ?x ⟹ ?R⟧ ⟹ ?R"
+ Unificador de ("¬Q(c)", "∀x. (P(x) ⟶ ¬Q(x))") y
("?R", "∀x. ?P x")
es ?R / ¬Q(c)
?P x / P(x) ⟶ ¬Q(x)
+ Nuevo objetivo: "⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c"

apply (erule mp)
+ Objetivo: "⟦P c; P ?x ⟶ ¬ Q ?x⟧ ⟹ ¬ Q c"
+ mp: "⟦?P ⟶ ?Q; ?P⟧ ⟹ ?Q"
+ Unificador de ("¬ Q c", "P ?x ⟶ ¬ Q ?x") y
("?Q", "?P ⟶ ?Q")
es ?Q / ¬ Q c
?P / P c
+ Nuevo objetivo: "P c ⟹ P c"
*}

lemma ej2: "⟦∀x. (P x ⟶ ¬(Q x)); ∀y. P y⟧ ⟹ ∀z. ¬(Q z)"
apply (rule allI) (* da ⋀z. ⟦P (?x2 z) ⟶ ¬ Q (?x2 z);
P (?y4 z)⟧
⟹ ¬ Q z*)
apply (erule allE)+ (* da ⋀z. ⟦P (?x2 z) ⟶ ¬ Q (?x2 z);
P (?y4 z)⟧
⟹ ¬ Q z *)
apply (erule mp) (* da ⋀z. P (?y4 z) ⟹ P z *)
apply assumption (* da No subgoals! *)
done

subsection "Reglas del cuantificador existencial"

lemma ej3: "∀x. P x ⟹ ∃y. P y"
apply (erule allE) (* da P ?x ⟹ ∃y. P y *)
apply (erule exI) (* da No subgoals! *)
done

lemma ej4: "⟦∀x. P x ⟶ Q x; ∃y. P y⟧ ⟹ ∃z. Q z"
apply (erule exE) (* da ⋀y. ⟦∀x. P x ⟶ Q x; P y⟧ ⟹ ∃z. Q z *)
apply (erule allE) (* da ⋀y. ⟦P y; P (?x2 y) ⟶ Q (?x2 y)⟧ ⟹ ∃z. Q z *)
apply (rule exI) (* da ⋀y. ⟦P y; P (?x2 y) ⟶ Q (?x2 y)⟧ ⟹ Q (?z4 y) *)
apply (erule mp) (* da ⋀y. P y ⟹ P (?x2 y) *)
apply assumption (* da No subgoals! *)
done

subsection "Demostraciones de equivalencias"

lemma ej5a: "¬(∀x. P x) ⟹ ∃y. ¬P y"
apply (rule ccontr) (* da ⟦¬ (∀x. P x); ∄y. ¬ P y⟧ ⟹ False *)
apply (erule notE) (* da ∄y. ¬ P y ⟹ ∀x. P x *)
apply (rule allI) (* da ⋀x. ∄y. ¬ P y ⟹ P x *)
apply (rule ccontr) (* da ⋀x. ⟦∄y. ¬ P y; ¬ P x⟧ ⟹ False *)
apply (erule notE) (* da ⋀x. ¬ P x ⟹ ∃y. ¬ P y *)
apply (erule exI) (* da No subgoals! *)
done

lemma ej5b: "∃x. ¬P x ⟹ ¬(∀y. P y)"
apply (rule notI) (* da ⟦∃x. ¬ P x; ∀y. P y⟧ ⟹ False *)
apply (erule exE) (* da ⋀x. ⟦∀y. P y; ¬ P x⟧ ⟹ False *)
apply (erule allE) (* da ⋀x. ⟦¬ P x; P (?y4 x)⟧ ⟹ False *)
apply (erule notE) (* da ⋀x. P (?y4 x) ⟹ P x *)
apply assumption (* da No subgoals! *)
done

lemma ej5: "¬(∀x. P x) ⟷ (∃x. ¬P x)"
apply (rule iffI) (* da ¬ (∀x. P x) ⟹ ∃x. ¬ P x
∃x. ¬ P x ⟹ ¬ (∀x. P x) *)
apply (erule ej5a) (* da ∃x. ¬ P x ⟹ ¬ (∀x. P x) *)
apply (erule ej5b) (* da No subgoals! *)
done

lemma ej6a: "∀x. P(x) ∧ Q(x) ⟹ (∀x. P x) ∧ (∀x. Q x)"
apply (rule conjI) (* da ∀x. P x ∧ Q x ⟹ ∀x. P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (rule allI) (* da ⋀x. ∀x. P x ∧ Q x ⟹ P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (erule allE) (* da ⋀x. P (?x5 x) ∧ Q (?x5 x) ⟹ P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (erule conjE) (* da ⋀x. ⟦P (?x5 x); Q (?x5 x)⟧ ⟹ P x
∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply assumption (* da ∀x. P x ∧ Q x ⟹ ∀x. Q x *)
apply (rule allI) (* da ⋀x. ∀x. P x ∧ Q x ⟹ Q x *)
apply (erule allE) (* da ⋀x. P (?x11 x) ∧ Q (?x11 x) ⟹ Q x *)
apply (erule conjE) (* da ⋀x. ⟦P (?x11 x); Q (?x11 x)⟧ ⟹ Q x *)
apply assumption (* da No subgoals! *)
done

lemma ej6b: "(∀x. P x) ∧ (∀x. Q x) ⟹ ∀x. P x ∧ Q x"
apply (rule allI) (* da ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ P x ∧ Q x *)
apply (rule conjI) (* da ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ P x
⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x *)
apply (drule conjunct1) (* da ⋀x. ∀x. P x ⟹ P x
⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x*)
apply (erule spec) (* da ⋀x. (∀x. P x) ∧ (∀x. Q x) ⟹ Q x *)
apply (drule conjunct2) (* da ⋀x. ∀x. Q x ⟹ Q x *)
apply (erule spec) (* da No subgoals! *)
done

lemma ej6: "(∀x. P x ∧ Q x) ⟷ (∀x. P x) ∧ (∀x. Q x)"
apply (rule iffI) (* da ∀x. P x ∧ Q x ⟹ (∀x. P x) ∧ (∀x. Q x)
(∀x. P x) ∧ (∀x. Q x) ⟹ ∀x. P x ∧ Q x *)
apply (erule ej6a) (* da (∀x. P x) ∧ (∀x. Q x) ⟹ ∀x. P x ∧ Q x *)
apply (erule ej6b) (* da No subgoals! *)
done

lemma ej7a: "(∃x. P x) ∨ (∃x. Q x) ⟹ ∃x. P x ∨ Q x"
apply (erule disjE) (* da ∃x. P x ⟹ ∃x. P x ∨ Q x
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule exE) (* da ⋀x. P x ⟹ ∃x. P x ∨ Q x
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (rule exI) (* da ⋀x. P x ⟹ P (?x5 x) ∨ Q (?x5 x)
∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule disjI1) (* da ∃x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (erule exE) (* da ⋀x. Q x ⟹ ∃x. P x ∨ Q x *)
apply (rule exI) (* da ⋀x. Q x ⟹ P (?x10 x) ∨ Q (?x10 x) *)
apply (erule disjI2) (* da No subgoals! *)
done

lemma ej7b: "∃x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x)"
apply (erule exE) (* da ⋀x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x)*)
apply (erule disjE) (* da ⋀x. P x ⟹ (∃x. P x) ∨ (∃x. Q x)
⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (rule disjI1) (* da ⋀x. P x ⟹ ∃x. P x
⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule exI) (* da ⋀x. Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (rule disjI2) (* da ⋀x. Q x ⟹ ∃x. Q x *)
apply (erule exI) (* da No subgoals! *)
done

lemma ej7: "(∃x. P x) ∨ (∃x. Q x) ⟷ (∃x. P x ∨ Q x)"
apply (rule iffI) (* da (∃x. P x) ∨ (∃x. Q x) ⟹ ∃x. P x ∨ Q x
∃x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule ej7a) (* da ∃x. P x ∨ Q x ⟹ (∃x. P x) ∨ (∃x. Q x) *)
apply (erule ej7b) (* da No subgoals! *)
done

lemma ej8a: "∃x y. P x y ⟹ ∃y x. P x y"
apply (erule exE)+ (* da ⋀x y. P x y ⟹ ∃y x. P x y *)
apply (rule exI)+ (* da ⋀x y. P x y ⟹ P (?x6 x y) (?y4 x y) *)
apply assumption (* da No subgoals! *)
done

lemma ej8b: "∃y x. P x y ⟹ ∃x y. P x y"
apply (erule exE)+ (* da ⋀y x. P x y ⟹ ∃x y. P x *)
apply (rule exI)+ (* da ⋀y x. P x y ⟹ P (?x4 y x) (?y6 y x)*)
apply assumption (* da No subgoals! *)
done

lemma ej8: "(∃x y. P x y) ⟷ (∃y x. P x y)"
apply (rule iffI) (* da ∃x y. P x y ⟹ ∃y x. P x y
∃y x. P x y ⟹ ∃x y. P x y *)
apply (erule ej8a) (* da ∃y x. P x y ⟹ ∃x y. P x y *)
apply (erule ej8b) (* da No subgoals! *)
done

end
</source>

Deducción natural proposicional con Isabelle/HOL basada en tácticas

2019-03-26T06:19:34Z

Jalonso:

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

section "Introducción"

subsection "Enunciado de teoremas"

theorem primerEjemplo: "(A ⟶ B) ∨ (B ⟶ A)"
oops

subsection "Demostración por asunción"

lemma "⟦A; B; C⟧ ⟹ B"
apply assumption
done

subsection "Ejemplo de aplicación de rule"

text {* 1º ejemplo de aplicación de rule *}
lemma "A ∧ B ⟹ B ∧ A"
apply (rule conjI)
oops

text {* 2º ejemplo de aplicación de rule *}
lemma "A ∧ B ⟹ B ∨ A"
apply (rule disjI1)
oops

lemma "⟦(A ∧ B) ∨ C; D⟧ ⟹ B ∨ C"
apply (rule disjE)
apply assumption
oops

subsection "Ejemplo de demostración con rule y assumption"

theorem K: "A ⟶ (B ⟶ A)"
apply (rule impI) (* da A ⟹ B ⟶ A *)
apply (rule impI) (* da ⟦A; B⟧ ⟹ A *)
apply assumption (* da No subgoals! *)
done

subsection "Ejemplo de derivación con hipótesis"

text {* Derivación de A, B ⊢ A ∧ (B ∧ A) *}
theorem "⟦A; B⟧ ⟹ A ∧ (B ∧ A)"
apply (rule conjI) (* da ⟦A; B⟧ ⟹ A
⟦A; B⟧ ⟹ B ∧ A *)
apply assumption (* da ⟦A; B⟧ ⟹ B ∧ A *)
apply (rule conjI) (* da ⟦A; B⟧ ⟹ B
⟦A; B⟧ ⟹ A *)
apply assumption (* da ⟦A; B⟧ ⟹ A *)
apply assumption (* da No subgoals *)
done

text {* La prueba anterior se puede simplificar usando assumption+ *}
theorem "⟦A; B⟧ ⟹ A ∧ (B ∧ A)"
apply (rule conjI) (* da ⟦A; B⟧ ⟹ A
⟦A; B⟧ ⟹ B ∧ A *)
apply assumption (* da ⟦A; B⟧ ⟹ B ∧ A *)
apply (rule conjI) (* da ⟦A; B⟧ ⟹ B
⟦A; B⟧ ⟹ A *)
apply assumption+ (* da No subgoals *)
done

subsection "Ejemplo de aplicación de erule"

lemma "⟦(A ∧ B) ∨ C; D⟧ ⟹ B ∨ C"
apply (erule disjE)
oops

text {* Demostración con erule *}
lemma "A ∨ B ⟹ B ∨ A"
apply (erule disjE) (* da A ⟹ B ∨ A
B ⟹ B ∨ A*)
apply (rule disjI2) (* da A ⟹ A
B ⟹ B ∨ A *)
apply assumption (* da B ⟹ B ∨ A *)
apply (rule disjI1) (* da B ⟹ B *)
apply assumption (* da No subgoals *)
done

text {* Variación de la demostración anterior cambiando erule por rule *}
lemma "A ∨ B ⟹ B ∨ A"
apply (rule disjE) (* da A ∨ B ⟹ ?P ∨ ?Q
⟦A ∨ B; ?P⟧ ⟹ B ∨ A
⟦A ∨ B; ?Q⟧ ⟹ B ∨ A *)
apply assumption (* da ⟦A ∨ B; A⟧ ⟹ B ∨ A
⟦A ∨ B; B⟧ ⟹ B ∨ A *)
apply (rule disjI2) (* da ⟦A ∨ B; A⟧ ⟹ A
⟦A ∨ B; B⟧ ⟹ B ∨ A*)
apply assumption (* da ⟦A ∨ B; B⟧ ⟹ B ∨ A *)
apply (rule disjI1) (* da ⟦A ∨ B; B⟧ ⟹ B *)
apply assumption (* da No subgoals! *)
done

subsection "Ejemplo de aplicación de drule"

lemma "⟦A ⟶ B; A ∧ C⟧ ⟹ B ∧ C"
apply (drule mp)
oops

text {* Demostración con drule *}
lemma "A ∧ B ⟹ A"
apply (drule conjunct1) (* da A ⟹ A *)
apply assumption (* da No subgoals! *)
done

subsection "Ejemplo de aplicación de frule"

lemma "⟦A ⟶ B; A ∧ C⟧ ⟹ B ∧ C"
apply (frule mp)
oops

text {* Demostración con frule *}
lemma "A ∧ B ⟹ A"
apply (frule conjunct1) (* da ⟦A ∧ B; A⟧ ⟹ A *)
apply assumption (* da No subgoals! *)
done

subsection "Ejemplo de aplicación de erule_tac"

lemma "⟦A ∧ B; C ∧ (B ∧ D)⟧ ⟹ B ∧ D"
apply (erule_tac Q="B ∧ D" in conjE)
apply assumption
done

lemma "⟦A ∧ B; C ∧ (B ∧ D)⟧ ⟹ B ∧ D"
apply (erule conjE)
oops

text {* Demostración con erule_tac *}
lemma "⟦A ∧ B; C ∧ D⟧ ⟹ D"
apply (erule_tac P=C in conjE) (* da ⟦A ∧ B; C; D⟧ ⟹ D *)
apply assumption (* da No subgoals! *)
done

text {* Demostración sin erule_tac *}
lemma "⟦A ∧ B; C ∧ D⟧ ⟹ D"
apply (erule conjE) (* da ⟦C ∧ D; A; B⟧ ⟹ D *)
apply (erule conjE) (* da ⟦A; B; C; D⟧ ⟹ D *)
apply assumption (* da No subgoals! *)
done

subsection "Cálculo de secuentes"

lemma "A ⟹ P ∧ Q"
apply (rule conjI)
oops

lemma "⟦A; P ∧ Q⟧ ⟹ R"
apply (erule conjE)
oops

lemma "A ⟹ P ∨ Q"
apply (rule disjI1)
oops

lemma "A ⟹ P ∨ Q"
apply (rule disjI2)
oops

lemma "⟦A; P ∨ Q⟧ ⟹ R"
apply (erule disjE)
oops

lemma "A ⟹ P ⟶ Q"
apply (rule impI)
oops

lemma "⟦A; P ⟶ Q⟧ ⟹ R"
apply (erule impE)
oops

lemma "⟦A; False⟧ ⟹ P"
apply (erule FalseE)
done

lemma "A ⟹ ¬P"
apply (rule notI)
oops

lemma "⟦A; P; ¬P⟧ ⟹ R"
apply (erule notE, assumption)
done

lemma "A ⟹ ¬P ∨ P"
apply (rule excluded_middle)
done

subsection "Ejemplos de pruebas"

lemma "((S ∨ R) ∧ ¬S) ⟶ R"
apply (rule impI) (* da (S ∨ R) ∧ ¬ S ⟹ R *)
apply (frule conjunct1) (* da ⟦(S ∨ R) ∧ ¬ S; S ∨ R⟧ ⟹ R *)
apply (erule disjE) (* da ⟦(S ∨ R) ∧ ¬ S; S⟧ ⟹ R
⟦(S ∨ R) ∧ ¬ S; R⟧ ⟹ R *)
apply (drule conjunct2) (* da ⟦S; ¬ S⟧ ⟹ R
⟦(S ∨ R) ∧ ¬ S; R⟧ ⟹ R *)
apply (erule notE) (* da S ⟹ S
⟦(S ∨ R) ∧ ¬ S; R⟧ ⟹ R *)
apply assumption+ (* da No subgoals! *)
done

lemma "(C ∨ P) ∧ (C ⟶ S) ∧ ¬P ⟶ S"
apply (rule impI) (* da (C ∨ P) ∧ (C ⟶ S) ∧ ¬ P ⟹ S *)
apply (erule conjE)+ (* da ⟦C ∨ P; C ⟶ S; ¬ P⟧ ⟹ S *)
apply (erule disjE) (* da ⟦C ⟶ S; ¬ P; C⟧ ⟹ S
⟦C ⟶ S; ¬ P; P⟧ ⟹ S *)
apply (erule impE) (* da ⟦¬ P; C⟧ ⟹ C
⟦¬ P; C; S⟧ ⟹ S
⟦C ⟶ S; ¬ P; P⟧ ⟹ S *)
apply assumption+ (* da ⟦C ⟶ S; ¬ P; P⟧ ⟹ S *)
apply (erule notE) (* da ⟦C ⟶ S; P⟧ ⟹ P *)
apply assumption (* da No subgoals! *)
done

subsection "La regla de corte"

lemma aux: "A ⟹ A ∨ B"
sorry

lemma "P ∧ Q ⟹ Q"
apply (cut_tac aux)
oops

lemma "¬(¬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 {* Ejemplo de case_tac *}
lemma "P ∧ Q ⟹ Q"
apply (case_tac "P") (* da ⟦P ∧ Q; P⟧ ⟹ Q
⟦P ∧ Q; ¬ P⟧ ⟹ Q *)
oops

text {* La demostración anterior usando case_tac *}
lemma "¬(¬p ∧ ¬q) ⟹ p ∨ q"
apply (case_tac p)
apply (erule disjI1)
apply (case_tac q)
apply (erule disjI2)
apply (erule notE)
apply (rule conjI)
apply assumption+
done

subsection "Ejemplo de demostración automática"

lemma "⟦A ∧ B; C ∧ (B ∧ D)⟧ ⟹ B ∧ D"
apply simp
done

section "Ejemplos del tema 2"

subsection {* Reglas de la conjunción *}

text {*
Ejemplo 1 (p. 4). Demostrar que
p ∧ q, r ⊢ q ∧ r.
*}

lemma ejemplo_1: "⟦p ∧ q; r⟧ ⟹ q ∧ r"
apply (rule conjI)
apply (erule conjunct2)
apply assumption
done

subsection {* Reglas de la doble negación *}

text {*
La regla de eliminación de la doble negación es
· notnotD: ¬¬ P ⟹ P

Para ajustarnos al tema de LI vamos a introducir la siguiente regla de
introducción de la doble negación
· notnotI: P ⟹ ¬¬ P
aunque, de momento, no detallamos su demostración.
*}

lemma notnotI [intro!]: "P ⟹ ¬¬ P"
by auto

text {*
Ejemplo 2. (p. 5)
p, ¬¬(q ∧ r) ⊢ ¬¬p ∧ r
*}

lemma ejemplo_2_A: "⟦p; ¬¬(q ∧ r) ⟧ ⟹ ¬¬p ∧ r"
apply (rule conjI)
apply (rule notnotI)
apply assumption
apply (drule notnotD)
apply (erule conjunct2)
done

subsection {* Regla de eliminación del condicional *}

text {*
La regla de eliminación del condicional es la regla del modus ponens
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
*}

text {*
Ejemplo 3. (p. 6) Demostrar que
¬p ∧ q, ¬p ∧ q ⟶ r ∨ ¬p ⊢ r ∨ ¬p
*}

lemma ejemplo_3: "⟦¬p ∧ q; ¬p ∧ q ⟶ r ∨ ¬p⟧ ⟹ r ∨ ¬p"
apply (erule mp)
apply assumption
done

text {*
Ejemplo 4 (p. 6) Demostrar que
p, p ⟶ q, p ⟶ (q ⟶ r) ⊢ r
*}

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

subsection {* Regla derivada del modus tollens *}

text {*
Para ajustarnos al tema de LI vamos a introducir la regla del modus
tollens
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
aunque, de momento, sin detallar su demostración.
*}

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

text {*
Ejemplo 5 (p. 7). Demostrar
p ⟶ (q ⟶ r), p, ¬r ⊢ ¬q
*}

lemma ejemplo_5_: "⟦p ⟶ (q ⟶ r); p; ¬r ⟧ ⟹ ¬q"
apply (drule mp)
apply assumption
apply (erule mt)
apply assumption
done

text {*
Ejemplo 6. (p. 7) Demostrar
¬p ⟶ q, ¬q ⊢ p
*}

lemma ejemplo_6: "⟦¬p ⟶ q; ¬q⟧ ⟹ p"
apply (drule mt)
apply assumption
apply (erule notnotD)
done

text {*
Ejemplo 7. (p. 7) Demostrar
p ⟶ ¬q, q ⊢ ¬p
*}

lemma ejemplo_7: "⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
apply (erule mt)
apply (erule notnotI)
done

subsection {* Regla de introducción del condicional *}

text {*
La regla de introducción del condicional es
· impI: (P ⟹ Q) ⟹ P ⟶ Q
*}

text {*
Ejemplo 8. (p. 8) Demostrar
p ⟶ q ⊢ ¬q ⟶ ¬p
*}

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

text {*
Ejemplo 9. (p. 9) Demostrar
¬q ⟶ ¬p ⊢ p ⟶ ¬¬q
*}

lemma ejemplo_9: "¬q ⟶ ¬p ⟹ p ⟶ ¬¬q"
apply (rule impI)
apply (erule mt)
apply (rule notnotI)
apply assumption
done

text {*
Ejemplo 10 (p. 9). Demostrar
⊢ p ⟶ p
*}

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

text {*
Ejemplo 11 (p. 10) Demostrar
⊢ (q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))
*}

lemma ejemplo_11_A: "(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
apply (rule impI)+
apply (erule mp)
apply (drule mt)
apply (rule notnotI)
apply assumption
apply (rule notnotD)
apply assumption
done

subsection {* Reglas de la disyunción *}

text {*
Las reglas de la introducción de la disyunción son
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
La regla de elimación de la disyunción es
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
*}

text {*
Ejemplo 12 (p. 11). Demostrar
p ∨ q ⊢ q ∨ p
*}

lemma ejemplo_12: "p ∨ q ⟹ q ∨ p"
apply (erule disjE)
apply (rule disjI2)
prefer 2
apply (rule disjI1)
apply assumption+
done

text {*
Ejemplo 13. (p. 12) Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
*}

lemma ejemplo_13_A: "q ⟶ r ⟹ p ∨ q ⟶ p ∨ r"
apply (rule impI)
apply (erule disjE)
apply (rule disjI1)
prefer 2
apply (drule mp)
prefer 2
apply (rule disjI2)
apply assumption+
done

subsection {* Regla de copia *}

text {*
Ejemplo 14 (p. 13). Demostrar
⊢ p ⟶ (q ⟶ p)
*}

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

subsection {* Reglas de la negación *}

text {*
La regla de eliminación de lo falso es
· FalseE: False ⟹ P
La regla de eliminación de la negación es
· notE: ⟦¬P; P⟧ ⟹ R
La regla de introducción de la negación es
· notI: (P ⟹ False) ⟹ ¬P
*}

text {*
Ejemplo 15 (p. 15). Demostrar
¬p ∨ q ⊢ p ⟶ q
*}

lemma ejemplo_15: "¬p ∨ q ⟹ p ⟶ q"
apply (rule impI)
apply (erule disjE)
apply (erule notE)
apply assumption+
done

text {*
Ejemplo 16 (p. 16). Demostrar
p ⟶ q, p ⟶ ¬q ⊢ ¬p
*}

lemma ejemplo_16_A: "⟦p ⟶ q; p ⟶ ¬q⟧ ⟹ ¬p"
apply (rule notI)
apply (drule mp)+
apply assumption+
apply (drule mp)
prefer 2
apply (erule notE)
apply assumption+
done

subsection {* Reglas del bicondicional *}

text {*
La regla de introducción del bicondicional es
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P ⟷ Q
Las reglas de eliminación del bicondicional son
· iffD1: ⟦Q ⟷ P; Q⟧ ⟹ P
· iffD2: ⟦P ⟷ Q; Q⟧ ⟹ P
*}

text {*
Ejemplo 17 (p. 17) Demostrar
*}

lemma ejemplo_17: "(p ∧ q) ⟷ (q ∧ p)"
apply (rule iffI)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
apply (rule conjI)
apply (erule conjunct2)
apply (erule conjunct1)
done

text {*
Ejemplo 18 (p. 18). Demostrar
p ⟷ q, p ∨ q ⊢ p ∧ q
*}

lemma ejemplo_18_A: "⟦p ⟷ q; p ∨ q⟧ ⟹ p ∧ q"
apply (erule disjE)
apply (rule conjI)
apply assumption
apply (erule iffD1)
apply assumption
apply (rule conjI)
apply (erule iffD2)
apply assumption+
done

subsection {* Reglas derivadas *}

subsubsection {* Regla del modus tollens *}

text {*
Ejemplo 19 (p. 20) Demostrar la regla del modus tollens a partir de
las reglas básicas.
*}

lemma ejemplo_20: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"
apply (rule notI)
apply (drule mp)
apply assumption
apply (erule notE)
apply assumption
done

subsubsection {* Regla de la introducción de la doble negación *}

text {*
Ejemplo 21 (p. 21) Demostrar la regla de introducción de la doble
negación a partir de las reglas básicas.
*}

lemma ejemplo_21_A: "F ⟹ ¬¬F"
apply (rule notI)
apply (erule notE)
apply assumption
done

subsubsection {* Regla de reducción al absurdo *}

text {*
La regla de reducción al absurdo en Isabelle se corresponde con la
regla clásica de contradicción
· ccontr: (¬P ⟹ False) ⟹ P
*}

subsubsection {* Ley del tercio excluso *}

text {*
La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
*}

text {*
Ejemplo 22 (p. 23). Demostrar la ley del tercio excluso a partir de
las reglas básicas.
*}

lemma ejemplo_22: "F ∨ ¬F"
oops

text {*
Ejemplo 23 (p. 24). Demostrar
p ⟶ q ⊢ ¬p ∨ q
*}

lemma ejemplo_23: "p ⟶ q ⟹ ¬p ∨ q"
apply (cut_tac P="p" in excluded_middle)
apply (erule disjE)
apply (rule disjI1)
prefer 2
apply (drule mp)
prefer 2
apply (rule disjI2)
apply assumption+
done

subsection {* Demostraciones por contradicción *}

text {*
Ejemplo 24. Demostrar que
¬p, p ∨ q ⊢ q
*}

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

end
</source>

=== Bibliografía ===

* [http://www.phil.cmu.edu/~avigad/formal/FormalCheatSheet.pdf Isabelle / Proof General Cheat Sheet].
* [https://isabelle.in.tum.de/dist/Isabelle2018/doc/tutorial.pdf Isabelle/HOL: A Proof Assistant for Higher-Order Logic]. Cap. 5: The Rules of the Game.

Deducción natural en lógica de primer orden con Isabelle/HOL basada en tácticas

2019-03-26T06:19:06Z

Jalonso:

Deducción natural en lógica de primer orden con Isabelle/HOL basada en tácticas

2019-03-26T06:17:36Z

Jalonso: