Razonamiento automático (2013-14) - Contribuciones del usuario [es]

Razonamiento automático (2013-14)

2018-07-16T19:07:05Z

WikiSysop:

Este sitio contiene materiales del curso ''Razonamiento automático'' del [http://master.cs.us.es/Máster_Universitario_en_Lógica,_Computación_e_Inteligencia_Artificial Máster Universitario en Lógica, Computación e Inteligencia Artificial] de la [http://www.us.es Universidad de Sevilla].

== Material para el curso ==
* [[Temas]]: Teorías de los temas.
* [[Ejercicios]]: Relaciones de ejercicios.
* [[Documentación]]: Lecturas recomendadas.
* [[Sistemas]]: Sistemas utilizados.
* [http://www.glc.us.es/~jalonso/vestigium/tag/ra2013 Diario]: Descripción diaria de las clases.

Ejercicios

2018-07-16T15:48:18Z

WikiSysop:

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.
* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]]).
* '''Relación 4''': Cons inverso. ([[R4 |Enunciado]]).
* '''Relación 5''': Cuantificadores sobre listas. ([[R5 |Enunciado]]).
* '''Relación 6''': Sustitución, inversión y eliminación. ([[R6 |Enunciado]]).
* '''Relación 7''': Recorridos de árboles. ([[R7 |Enunciado]]).
* '''Relación 8''': Árboles binarios completos. ([[R8 |Enunciado]]).
* '''Relación 9''': Deducción natural proposicional (1). ([[R9 |Enunciado]]).
* '''Relación 10''': Deducción natural proposicional (2). ([[R10 |Enunciado]]).
* '''Relación 11''': Deducción natural proposicional de primer orden. ([[R11 |Enunciado]]).
* '''Relación 12''': Representación de fórmulas proposicionales mediante polinomios. ([[R12 |Enunciado]]).

Tema 6b: Deducción natural proposicional con Isabelle/HOL

2018-07-16T15:46:19Z

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

<source lang="isabelle">
header {* Tema 6b: Deducción natural proposicional con Isabelle/HOL *}

theory T6b
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. *}

subsection {* Reglas de la conjunción *}

text {*
Ejemplo 1 (p. 4). Demostrar que
p ∧ q, r ⊢ q ∧ r.
*}

-- "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
thm ejemplo_1_1
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
*}

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) ..
thus "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
· "thus" para demostrar la conclusión usando el hecho anterior.
Además, no es necesario usar and entre las hipótesis. *}

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

text {* Se puede automatizar totalmente la demostración como sigue *}

lemma ejemplo_1_5:
"⟦p ∧ q; r⟧ ⟹ q ∧ r"
by auto

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

text {* Se puede hacer la demostración por razonamiento hacia atrás,
como sigue *}

lemma ejemplo_1_6:
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. *}

text {* Se pueden dejar implícitas las reglas como sigue *}

lemma ejemplo_1_7:
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. *}

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

-- "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

-- "La demostración estructurada es"
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)
hence "r" ..
with `¬¬p` show "¬¬p ∧ r" ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "hence" para indicar que se tiene por el hecho anterior,
· `...` para referenciar un hecho y
· "with P show Q" para indicar que con el hecho anterior junto con el
hecho P se demuestra Q. *}

-- "La demostración automática es"
lemma ejemplo_2_3:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
using assms
by auto

text {* Se puede demostrar hacia atrás *}

lemma ejemplo_2_4:
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)
thus "r" by (rule conjunct2)
qed

text {* Se puede eliminar las reglas en la demostración anterior, como
sigue: *}

lemma ejemplo_2_5:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof
show "¬¬p" using assms(1) ..
next
have "q ∧ r" using assms(2) by (rule notnotD)
thus "r" ..
qed

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

-- "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

-- "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

-- "La demostración automática es"
lemma ejemplo_3_3:
assumes "¬p ∧ q"
"¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
using assms
by auto

text {*
Ejemplo 4 (p. 6) Demostrar que
p, p ⟶ q, p ⟶ (q ⟶ r) ⊢ r
*}

-- "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

-- "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) ..
thus "r" using `q` ..
qed

-- "La demostración automática es"
lemma ejemplo_4_3:
"⟦p; p ⟶ q; p ⟶ (q ⟶ r)⟧ ⟹ r"
by auto

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

-- "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

-- "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) ..
thus "¬q" using assms(3) by (rule mt)
qed

-- "La demostración automática es"
lemma ejemplo_5_3:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
using assms
by auto

text {*
Ejemplo 6. (p. 7) Demostrar
¬p ⟶ q, ¬q ⊢ p
*}

-- "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

-- "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)
thus "p" by (rule notnotD)
qed

-- "La demostración automática es"
lemma ejemplo_6_3:
"⟦¬p ⟶ q; ¬q⟧ ⟹ p"
by auto

text {*
Ejemplo 7. (p. 7) Demostrar
p ⟶ ¬q, q ⊢ ¬p
*}

-- "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

-- "La demostración estructurada es"
lemma ejemplo_7_3:
"⟦p ⟶ ¬q; q⟧ ⟹ ¬p"
by auto

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

-- "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) }
thus "¬q ⟶ ¬p" by (rule impI)
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "{ ... }" para representar una caja. *}

-- "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

-- "La demostración automática es"
lemma ejemplo_8_3:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
using assms
by auto

text {*
Ejemplo 9. (p. 9) Demostrar
¬q ⟶ ¬p ⊢ p ⟶ ¬¬q
*}

-- "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) }
thus "p ⟶ ¬¬q" by (rule impI)
qed

-- "La demostración estructurada es"
lemma ejemplo_9_2:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms show "¬¬q" by (rule mt)
qed

-- "La demostración automática es"
lemma ejemplo_9_3:
assumes "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
using assms
by auto

text {*
Ejemplo 10 (p. 9). Demostrar
⊢ p ⟶ p
*}

-- "La demostración detallada es"
lemma ejemplo_10_1:
"p ⟶ p"
proof -
{ assume 1: "p"
have "p" using 1 by this }
thus "p ⟶ p" by (rule impI)
qed

-- "La demostración estructurada es"
lemma ejemplo_10_2:
"p ⟶ p"
proof (rule impI)
qed

-- "La demostración automática es"
lemma ejemplo_10_3:
"p ⟶ p"
by auto

text {*
Ejemplo 11 (p. 10) Demostrar
⊢ (q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))
*}

-- "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) }
hence "p ⟶ r" by (rule impI) }
hence "(¬q ⟶ ¬p) ⟶ p ⟶ r" by (rule impI) }
thus "(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

-- "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"
hence "¬¬p" ..
with `¬q ⟶ ¬p` have "¬¬q" by (rule mt)
hence "q" by (rule notnotD)
with `q ⟶ r` show "r" ..
qed
qed
qed

-- "La demostración automática es"
lemma ejemplo_11_5:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
by auto

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

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

-- "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"
hence "q ∨ p" .. }
moreover
{ assume "q"
hence "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. *}

-- "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

-- "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"
thus "q ∨ p" .. }
next
{ assume "q"
thus "q ∨ p" .. }
qed

-- "La demostración automática es"
lemma ejemplo_12_5:
assumes "p ∨ q"
shows "q ∨ p"
using assms
by auto

text {*
Ejemplo 13. (p. 12) Demostrar
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r
*}

-- "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"
thus "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

-- "La demostración estructurada es"
lemma ejemplo_13_2:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
thus "p ∨ r"
proof
{ assume "p"
thus "p ∨ r" .. }
next
{ assume "q"
have "r" using assms `q` ..
thus "p ∨ r" .. }
qed
qed

-- "La demostración automática es"
lemma ejemplo_13_3:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
using assms
by auto

subsection {* Regla de copia *}

text {*
Ejemplo 14 (p. 13). Demostrar
⊢ p ⟶ (q ⟶ p)
*}

-- "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

-- "La demostración estructurada es"
lemma ejemplo_14_2:
"p ⟶ (q ⟶ p)"
proof
assume "p"
thus "q ⟶ p" ..
qed

-- "La demostración automática es"
lemma ejemplo_14_3:
"p ⟶ (q ⟶ p)"
by auto

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

-- "La demostración detallada es"
lemma ejemplo_15_1:
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p"
note 1
thus "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

-- "La demostración estructurada es"
lemma ejemplo_15_2:
assumes "¬p ∨ q"
shows "p ⟶ q"
proof
assume "p"
note `¬p ∨ q`
thus "q"
proof
{ assume "¬p"
thus "q" using `p` .. }
next
{ assume "q"
thus "q" . }
qed
qed

-- "La demostración automática es"
lemma ejemplo_15_3:
assumes "¬p ∨ q"
shows "p ⟶ q"
using assms
by auto

text {*
Ejemplo 16 (p. 16). Demostrar
p ⟶ q, p ⟶ ¬q ⊢ ¬p
*}

-- "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

-- "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` ..
thus False using `q` ..
qed

-- "La demostración automática es"
lemma ejemplo_16_3:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
using assms
by auto

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

-- "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

-- "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

-- "La demostración automática es"
lemma ejemplo_17_3:
"(p ∧ q) ⟷ (q ∧ p)"
by auto

text {*
Ejemplo 18 (p. 18). Demostrar
p ⟷ q, p ∨ q ⊢ p ∧ q
*}

-- "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

-- "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" ..
thus "p ∧ q" using `q` .. }
qed

-- "La demostración automática es"
lemma ejemplo_18_3:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms
by auto

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

-- "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

-- "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

-- "La demostración automática es"
lemma ejemplo_20_3:
assumes "F ⟶ G"
"¬G"
shows "¬F"
using assms
by auto

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

-- "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

-- "La demostración estructurada es"
lemma ejemplo_21_2:
assumes "F"
shows "¬¬F"
proof
assume "¬F"
thus False using assms ..
qed

-- "La demostración automática es"
lemma ejemplo_21_3:
assumes "F"
shows "¬¬F"
using assms
by auto

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

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

-- "La demostración detallada es"
lemma ejemplo_22_1:
"F ∨ ¬F"
proof (rule ccontr)
assume 1: "¬(F ∨ ¬F)"
thus False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume 2: "F"
hence 3: "F ∨ ¬F" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
qed
qed
qed

-- "La demostración estructurada es"
lemma ejemplo_22_2:
"F ∨ ¬F"
proof (rule ccontr)
assume "¬(F ∨ ¬F)"
thus False
proof (rule notE)
show "F ∨ ¬F"
proof (rule disjI2)
show "¬F"
proof (rule notI)
assume "F"
hence "F ∨ ¬F" ..
with `¬(F ∨ ¬F)`show False ..
qed
qed
qed
qed

-- "La demostración automática es"
lemma ejemplo_22_3:
"F ∨ ¬F"
using assms
by auto

text {*
Ejemplo 23 (p. 24). Demostrar
p ⟶ q ⊢ ¬p ∨ q
*}

-- "La demostración detallada es"
lemma ejemplo_23_1:
assumes 1: "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" by (rule excluded_middle)
thus "¬p ∨ q"
proof (rule disjE)
{ assume "¬p"
thus "¬p ∨ q" by (rule disjI1) }
next
{ assume 2: "p"
have "q" using 1 2 by (rule mp)
thus "¬p ∨ q" by (rule disjI2) }
qed
qed

-- "La demostración estructurada es"
lemma ejemplo_23_2:
assumes "p ⟶ q"
shows "¬p ∨ q"
proof -
have "¬p ∨ p" ..
thus "¬p ∨ q"
proof
{ assume "¬p"
thus "¬p ∨ q" .. }
next
{ assume "p"
with assms have "q" ..
thus "¬p ∨ q" .. }
qed
qed

-- "La demostración automática es"
lemma ejemplo_23_3:
assumes "p ⟶ q"
shows "¬p ∨ q"
using assms
by auto

subsection {* Demostraciones por contradicción *}

text {*
Ejemplo 24. Demostrar que
¬p, p ∨ q ⊢ q
*}

-- "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"
thus "q" by assumption
qed

-- "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"
thus "q" .
qed

-- "La demostración automática es"
lemma ejemplo_24_3:
assumes "¬p"
"p ∨ q"
shows "q"
using assms
by auto

end
</source>

Tema 7b: Deducción natural en lógica de primer orden con Isabelle/HOL

2018-07-16T15:46:19Z

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

<source lang="isabelle">
header {* Tema 7: Deducción natural en lógica de primer orden *}

theory T7b_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 8 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
*}

text {*
Ejemplo 1 (p. 10). Demostrar que
P(c), ∀x. (P(x) ⟶ ¬Q(x)) ⊢ ¬Q(c)
*}

-- "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

-- "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) ..
thus "¬Q(c)" using assms(1) ..
qed

-- "La demostración automática es"
lemma ejemplo_1c:
assumes "P(c)"
"∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
using assms
by auto

text {*
Ejemplo 2 (p. 11). Demostrar que
∀x. (P x ⟶ ¬(Q x)), ∀x. P x ⊢ ∀x. ¬(Q x)
*}

-- "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) }
thus "∀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

-- "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) ..
thus "¬(Q a)" using `P a` ..
qed

-- "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

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

text {*
Ejemplo (p. 12). Demostrar que
∀x. P x ⊢ ∃x. P x
*}

-- "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)
thus "∃x. P x" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_3b:
assumes "∀x. P x"
shows "∃x. P x"
proof -
fix a
have "P a" using assms ..
thus "∃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

-- "La demostración automática es"
lemma ejemplo_3e:
assumes "∀x. P x"
shows "∃x. P x"
using assms
by auto

text {*
Ejemplo 4 (p. 13). Demostrar
∀x. (P x ⟶ Q x), ∃x. P x ⊢ ∃x. Q x
*}

-- "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)
thus 6: "∃x. Q x" by (rule exI)
qed

-- "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) ..
hence "Q a" using `P a` ..
thus "∃x. Q x" ..
qed

-- "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

section {* Demostración de equivalencias *}

text {*
Ejemplo 5.1 (p. 15). Demostrar
¬∀x. P x ⊢ ∃x. ¬(P x) *}

-- "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)"
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

-- "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)"
hence "∃x. ¬P(x)" ..
with `¬(∃x. ¬P(x))` show False ..
qed
qed
with assms show False ..
qed

-- "La demostración automática es"
lemma ejemplo_5_1c:
assumes "¬(∀x. P(x))"
shows "∃x. ¬P(x)"
using assms
by auto

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))"
thus "∃x. ¬P(x)" by (rule ejemplo_5_1a)
next
assume "∃x. ¬P(x)"
thus "¬(∀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)
thus "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)
thus "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 ..
thus "P(a)" ..
qed
next
show "∀x. Q(x)"
proof
fix a
have "P(a) ∧ Q(a)" using assms ..
thus "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)
hence "P(a)" by (rule allE)
have "∀x. Q(x)" using assms by (rule conjunct2)
hence "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 ..
hence "P(a)" by (rule allE)
have "∀x. Q(x)" using assms ..
hence "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)"
thus "(∀x. P(x)) ∧ (∀x. Q(x))" by (rule ejemplo_6_1a)
next
assume "(∀x. P(x)) ∧ (∀x. Q(x))"
thus "∀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)
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

-- "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)" ..
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

-- "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)
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

-- "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 ..
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 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))"
thus "∃x. P(x) ∨ Q(x)" by (rule ejemplo_7_1a)
next
assume "∃x. P(x) ∨ Q(x)"
thus "(∃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)
hence "∃x. P(x,b)" by (rule exI)
thus "∃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)" ..
hence "∃x. P(x,b)" ..
thus "∃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)
hence "∃y. P(a,y)" by (rule exI)
thus "∃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)" ..
hence "∃y. P(a,y)" ..
thus "∃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)"
thus "∃y x. P(x,y)" by (rule ejemplo_8_1a)
next
assume "∃y x. P(x,y)"
thus "∃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>

Tema 8: Caso de estudio: Compilación de expresiones

2018-07-16T15:46:19Z

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

<source lang="isabelle">
header {* Tema 8: Caso de estudio: Compilación de expresiones *}

theory T8
imports Main
begin

text {*
El objetivo de este tema es contruir un compilador de expresiones
genéricas (construidas con variables, constantes y operaciones
binarias) a una máquina de pila y demostrar su corrección.
*}

section {* Las expresiones y el intérprete *}

text {*
Definición. Las expresiones son las constantes, las variables
(representadas por números naturales) y las aplicaciones de operadores
binarios a dos expresiones.
*}

type_synonym 'v binop = "'v ⇒ 'v ⇒ 'v"

datatype 'v expr =
Const 'v
| Var nat
| App "'v binop" "'v expr" "'v expr"

text {*
Definición. [Intérprete]
La función "valor" toma como argumentos una expresión y un entorno
(i.e. una aplicación de las variables en elementos del lenguaje) y
devuelve el valor de la expresión en el entorno.
*}

fun valor :: "'v expr ⇒ (nat ⇒ 'v) ⇒ 'v" where
"valor (Const b) ent = b"
| "valor (Var x) ent = ent x"
| "valor (App f e1 e2) ent = (f (valor e1 ent) (valor e2 ent))"

text {*
Ejemplo. A continuación mostramos algunos ejemplos de evaluación con
el intérprete.
*}

lemma
"valor (Const 3) id = 3 ∧
valor (Var 2) id = 2 ∧
valor (Var 2) (λx. x+1) = 3 ∧
valor (App (op +) (Const 3) (Var 2)) (λx. x+1) = 6 ∧
valor (App (op +) (Const 3) (Var 2)) (λx. x+4) = 9"
by simp

section {* La máquina de pila *}

text {*
Nota. La máquina de pila tiene tres clases de intrucciones:
· cargar en la pila una constante,
· cargar en la pila el contenido de una dirección y
· aplicar un operador binario a los dos elementos superiores de la pila.
*}

datatype 'v instr =
IConst 'v
| ILoad nat
| IApp "'v binop"

text {*
Definición. [Ejecución]
La ejecución de la máquina de pila se modeliza mediante la función
"ejec" que toma una lista de intrucciones, una memoria (representada
como una función de las direcciones a los valores, análogamente a los
entornos) y una pila (representada como una lista) y devuelve la pila
al final de la ejecución.
*}

fun ejec :: "'v instr list ⇒ (nat ⇒ 'v) ⇒ 'v list ⇒ 'v list" where
"ejec [] ent vs = vs"
| "ejec (i#is) ent vs =
(case i of
IConst v ⇒ ejec is ent (v#vs)
| ILoad x ⇒ ejec is ent ((ent x)#vs)
| IApp f ⇒ ejec is ent ((f (hd vs) (hd (tl vs)))#(tl(tl vs))))"

text {*
A continuación se muestran ejemplos de ejecución.
*}

lemma
"ejec [IConst 3] id [7] = [3,7] ∧
ejec [ILoad 2, IConst 3] id [7] = [3,2,7] ∧
ejec [ILoad 2, IConst 3] (λx. x+4) [7] = [3,6,7] ∧
ejec [ILoad 2, IConst 3, IApp (op +)] (λx. x+4) [7] = [9,7]"
by simp

section {* El compilador *}

text {*
Definición. El compilador "comp" traduce una expresión en una lista de
instrucciones.
*}

fun comp :: "'v expr ⇒ 'v instr list" where
"comp (Const v) = [IConst v]"
| "comp (Var x) = [ILoad x]"
| "comp (App f e1 e2) = (comp e2) @ (comp e1) @ [IApp f]"

text {*
A continuación se muestran ejemplos de compilación.
*}

lemma
"comp (Const 3) = [IConst 3] ∧
comp (Var 2) = [ILoad 2] ∧
comp (App (op +) (Const 3) (Var 2)) = [ILoad 2, IConst 3, IApp (op +)]"
by simp

section {* Corrección del compilador *}

text {*
Para demostrar que el compilador es correcto, probamos que el
resultado de compilar una expresión y a continuación ejecutarla es lo
mismo que interpretarla; es decir,
*}

theorem "ejec (comp e) ent [] = [valor e ent]"
oops

text {*
El teorema anterior no puede demostrarse por inducción en e. Para
demostrarlo, lo generalizamos a
*}

theorem "∀vs. ejec (comp e) ent vs = (valor e ent)#vs"
oops

text {*
En la demostración del teorema anterior usaremos el siguiente lema.
*}

lemma ejec_append:
"∀ vs. ejec (xs@ys) ent vs = ejec ys ent (ejec xs ent vs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume "?P xs"
thus "?P (a#xs)" by (cases "a", auto)
qed

-- "La demostración detallada es"
lemma ejec_append_1:
"∀ vs. ejec (xs@ys) ent vs = ejec ys ent (ejec xs ent vs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
thus "?P (a#xs)"
proof (cases "a")
case IConst thus ?thesis using HI by simp
next
case ILoad thus ?thesis using HI by simp
next
case IApp thus ?thesis using HI by simp
qed
qed

text {*
Una demostración más detallada del lema es la siguiente:
*}

lemma ejec_append_2:
"∀vs. ejec (xs@ys) ent vs = ejec ys ent (ejec xs ent vs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
thus "?P (a#xs)"
proof (cases "a")
fix v assume C1: "a=IConst v"
show " ∀vs. ejec ((a#xs)@ys) ent vs = ejec ys ent (ejec (a#xs) ent vs)"
proof
fix vs
have "ejec ((a#xs)@ys) ent vs = ejec (((IConst v)#xs)@ys) ent vs"
using C1 by simp
also have "… = ejec (xs@ys) ent (v#vs)" by simp
also have "… = ejec ys ent (ejec xs ent (v#vs))" using HI by simp
also have "… = ejec ys ent (ejec ((IConst v)#xs) ent vs)" by simp
also have "… = ejec ys ent (ejec (a#xs) ent vs)" using C1 by simp
finally show "ejec ((a#xs)@ys) ent vs =
ejec ys ent (ejec (a#xs) ent vs)" .
qed
next
fix n assume C2: "a=ILoad n"
show " ∀vs. ejec ((a#xs)@ys) ent vs = ejec ys ent (ejec (a#xs) ent vs)"
proof
fix vs
have "ejec ((a#xs)@ys) ent vs = ejec (((ILoad n)#xs)@ys) ent vs"
using C2 by simp
also have "… = ejec (xs@ys) ent ((ent n)#vs)" by simp
also have "… = ejec ys ent (ejec xs ent ((ent n)#vs))" using HI by simp
also have "… = ejec ys ent (ejec ((ILoad n)#xs) ent vs)" by simp
also have "… = ejec ys ent (ejec (a#xs) ent vs)" using C2 by simp
finally show "ejec ((a#xs)@ys) ent vs =
ejec ys ent (ejec (a#xs) ent vs)" .
qed
next
fix f assume C3: "a=IApp f"
show "∀vs. ejec ((a#xs)@ys) ent vs = ejec ys ent (ejec (a#xs) ent vs)"
proof
fix vs
have "ejec ((a#xs)@ys) ent vs = ejec (((IApp f)#xs)@ys) ent vs"
using C3 by simp
also have "… = ejec (xs@ys) ent ((f (hd vs) (hd (tl vs)))#(tl(tl vs)))"
by simp
also have "… = ejec ys
ent
(ejec xs ent ((f (hd vs) (hd (tl vs)))#(tl(tl vs))))"
using HI by simp
also have "… = ejec ys ent (ejec ((IApp f)#xs) ent vs)" by simp
also have "… = ejec ys ent (ejec (a#xs) ent vs)" using C3 by simp
finally show "ejec ((a#xs)@ys) ent vs =
ejec ys ent (ejec (a#xs) ent vs)" .
qed
qed
qed

text {*
La demostración automática del teorema es
*}

theorem "∀vs. ejec (comp e) ent vs = (valor e ent)#vs"
by (induct e) (auto simp add:ejec_append)

text {*
La demostración estructurada del teorema es
*}

theorem "∀vs. ejec (comp e) ent vs = (valor e ent)#vs"
proof (induct e)
fix v
show "∀vs. ejec (comp (Const v)) ent vs = (valor (Const v) ent)#vs" by simp
next
fix x
show "∀vs. ejec (comp (Var x)) ent vs = (valor (Var x) ent) # vs" by simp
next
fix f e1 e2
assume HI1: "∀vs. ejec (comp e1) ent vs = (valor e1 ent) # vs"
and HI2: "∀vs. ejec (comp e2) ent vs = (valor e2 ent) # vs"
show "∀vs. ejec (comp (App f e1 e2)) ent vs = (valor (App f e1 e2) ent) # vs"
proof
fix vs
have "ejec (comp (App f e1 e2)) ent vs
= ejec ((comp e2) @ (comp e1) @ [IApp f]) ent vs" by simp
also have "… = ejec ((comp e1) @ [IApp f]) ent (ejec (comp e2) ent vs)"
using ejec_append by blast
also have "… = ejec [IApp f]
ent
(ejec (comp e1) ent (ejec (comp e2) ent vs))"
using ejec_append by blast
also have "… = ejec [IApp f] ent (ejec (comp e1) ent ((valor e2 ent)#vs))"
using HI2 by simp
also have "… = ejec [IApp f] ent ((valor e1 ent)#((valor e2 ent)#vs))"
using HI1 by simp
also have "… = (f (valor e1 ent) (valor e2 ent))#vs" by simp
also have "… = (valor (App f e1 e2) ent) # vs" by simp
finally
show "ejec (comp (App f e1 e2)) ent vs = (valor (App f e1 e2) ent) # vs"
by blast
qed
qed

end
</source>

Tema 4: Razonamiento por casos y por inducción

2018-07-16T15:46:18Z

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

<source lang="isabelle">
header {* Tema 4: Razonamiento por casos y por inducción *}

theory T4
imports Main 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 automática es"
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
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 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 dmostració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 automática es"
lemma "length (tl xs) = length xs - 1"
by auto

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

-- "La demostración automática es"
lemma "drop (n + 1) xs = drop n (tl xs)"
by (cases xs) auto

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

-- "La demostración automática es"
lemma "suma_impares n = n * n"
by (induct n) auto

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 detallada por inducción"
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, anter 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

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 estructurada es"
lemma espejo_involutiva:
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
*}

-- "La demostración automática es"
lemma espejo_involutiva_1:
"espejo (espejo a ) = a"
by (induct a) auto

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

-- "La demostración automática es"
lemma "aplana (espejo a) = rev (aplana a)"
by (induct a) 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"
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

section {* 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 a h) es el árbol obtenido aplicando la función h a
todos los nodos del árbol a.
· (map_bosque b h) es el bosque obtenido aplicando la función h 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)
*}

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

-- "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) auto

end
</source>

Tema 5a: Verificación de la ordenación por inserción

2018-07-16T15:46:18Z

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

<source lang="isabelle">
header {* T5a: Verificación de la ordenación por inserción *}

theory T5a_Verificacion_de_la_ordenacion_por_insercion
imports Main
begin

text {*
En este de tema se define el algoritmo de ordenación de listas
por inserción y se demuestra que es correcto. Se plantea como una
❙sucesión de ejercicios.
*}

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
inserta :: int ⇒ int list ⇒ int list
tal que (inserta a xs) es la lista obtenida insertando a delante del
primer elemento de xs que es mayor o igual que a. Por ejemplo,
inserta 3 [2,5,1,7] = [2,3,5,1,7]
------------------------------------------------------------------ *}

fun inserta :: "int ⇒ int list ⇒ int list" where
"inserta a [] = [a]"
| "inserta a (x#xs) = (if a ≤ x then a#x#xs
else x # inserta a xs)"

value "inserta 3 [2,5,1,7]" -- "= [2,3,5,1,7]"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
ordena :: int list ⇒ int list
tal que (ordena xs) es la lista obtenida ordenando xs por inserción.
Por ejemplo,
ordena [3,2,5,3] = [2,3,3,5]
------------------------------------------------------------------ *}

fun ordena :: "int list ⇒ int list" where
"ordena [] = []"
| "ordena (x#xs) = inserta x (ordena xs)"

value "ordena [3,2,5,3]" -- "[2,3,3,5]"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
menor :: int ⇒ int list ⇒ bool
tal que (menor a xs) se verifica si a es menor o igual que todos los
elementos de xs.Por ejemplo,
menor 2 [3,2,5] = True
menor 2 [3,0,5] = False
------------------------------------------------------------------ *}

fun menor :: "int ⇒ int list ⇒ bool" where
"menor a [] = True"
| "menor a (x#xs) = (a ≤ x ∧ menor a xs)"

value "menor 2 [3,2,5]" -- "= True"
value "menor 2 [3,0,5]" -- "= False"

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
ordenada :: int list ⇒ bool
tal que (ordenada xs) se verifica si xs es una lista ordenada de
manera creciente. Por ejemplo,
ordenada [2,3,3,5] = True
ordenada [2,4,3,5] = False
------------------------------------------------------------------ *}

fun ordenada :: "int list ⇒ bool" where
"ordenada [] = True"
| "ordenada (x#xs) = (menor x xs & ordenada xs)"

value "ordenada [2,3,3,5]" -- "= True"
value "ordenada [2,4,3,5]" -- "= False"

text {*
---------------------------------------------------------------------
Ejercicio 5. Demostrar que si y es una cota inferior de zs y x ≤ y,
entonces x es una cota inferior de zs.
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma menor_menor:
assumes "x ≤ y"
shows "menor y zs ⟶ menor x zs"
using assms
by (induct zs) auto

-- "La demostración estructurada es"
lemma menor_menor_2:
assumes "x ≤ y"
shows "menor y zs ⟶ menor x zs"
proof (induct zs)
show "menor y [] ⟶ menor x []" by simp
next
fix z zs
assume HI: "menor y zs ⟶ menor x zs"
show "menor y (z # zs) ⟶ menor x (z # zs)"
proof
assume sup: "menor y (z # zs)"
show "menor x (z # zs)"
proof (simp only: menor.simps(2))
show "x ≤ z ∧ menor x zs"
proof
have "x ≤ y" using assms .
also have "y ≤ z" using sup by simp
finally show "x ≤ z" .
next
have "menor y zs" using sup by simp
with HI show "menor x zs" by simp
qed
qed
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar el siguiente teorema de corrección: x es una
cota inferior de la lista obtenida insertando y en zs syss x ≤ y y x
es una cota inferior de zs.
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma menor_inserta:
"menor x (inserta y zs) = (x ≤ y ∧ menor x zs)"
by (induct zs) auto

-- "La demostración estructurada es"
lemma menor_inserta_2:
"menor x (inserta y zs) = (x ≤ y ∧ menor x zs)"
proof (induct zs)
show "menor x (inserta y []) = (x ≤ y ∧ menor x [])" by simp
next
fix z zs
assume HI: "menor x (inserta y zs) = (x ≤ y ∧ menor x zs)"
show "menor x (inserta y (z#zs)) = (x ≤ y ∧ menor x (z#zs))"
proof (cases "y ≤ z")
assume "y ≤ z"
hence "menor x (inserta y (z#zs)) = menor x (y#z#zs)" by simp
also have "… = (x ≤ y ∧ menor x (z#zs))" by simp
finally show ?thesis by simp
next
assume "¬(y ≤ z)"
hence "menor x (inserta y (z#zs)) =
menor x (z # inserta y zs)" by simp
also have "… = (x ≤ z ∧ menor x (inserta y zs))" by simp
also have "… = (x ≤ z ∧ x ≤ y ∧ menor x zs)" using HI by simp
also have "… = (x ≤ y ∧ menor x (z#zs))" by auto
finally show ?thesis by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que al insertar un elemento la lista obtenida
está ordenada syss lo estaba la original.
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma ordenada_inserta:
"ordenada (inserta a xs) = ordenada xs"
by (induct xs) (auto simp add: menor_menor menor_inserta)

-- "La demostración estructurada es"
lemma ordenada_inserta_2:
"ordenada (inserta a xs) = ordenada xs"
proof (induct xs)
show "ordenada (inserta a []) = ordenada []" by simp
next
fix x xs
assume HI: "ordenada (inserta a xs) = ordenada xs"
show "ordenada (inserta a (x # xs)) = ordenada (x # xs)"
proof (cases "a ≤ x")
assume "a ≤ x"
hence "ordenada (inserta a (x # xs)) =
ordenada (a # x # xs)" by simp
also have "… = (menor a (x#xs) ∧ ordenada (x # xs))" by simp
also have "… = ordenada (x # xs)"
using `a ≤ x` by (auto simp add: menor_menor)
finally show "ordenada (inserta a (x # xs)) = ordenada (x # xs)"
by simp
next
assume "¬(a ≤ x)"
hence "ordenada (inserta a (x # xs)) =
ordenada (x # inserta a xs)" by simp
also have "… = (menor x (inserta a xs) ∧ ordenada (inserta a xs))"
by simp
also have "… = (menor x (inserta a xs) ∧ ordenada xs)"
using HI by simp
also have "… = (menor x xs ∧ ordenada xs)"
using `¬(a ≤ x)` by (simp add: menor_inserta)
also have "… = ordenada (x # xs)" by simp
finally show "ordenada (inserta a (x # xs)) = ordenada (x # xs)"
by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que, para toda lista xs, (ordena xs) está
ordenada.
------------------------------------------------------------------ *}

-- "La demostración automática es"
theorem ordenada_ordena:
"ordenada (ordena xs)"
by (induct xs) (auto simp add: ordenada_inserta)

-- "La demostración estructurada es"
theorem ordenada_ordena_2:
"ordenada (ordena xs)"
proof (induct xs)
show "ordenada (ordena [])" by simp
next
fix x xs
assume "ordenada (ordena xs)"
then have "ordenada (inserta x (ordena xs))"
by (simp add: ordenada_inserta)
then show "ordenada (ordena (x # xs))" by simp
qed

text {*
---------------------------------------------------------------------
Nota. El teorema anterior no garantiza que ordena sea correcta, ya que
puede que (ordena xs) no tenga los mismos elementos que xs. Por
ejemplo, si se define (ordena xs) como [] se tiene que (ordena xs)
está ordenada pero no es una ordenación de xs.

Para garantizarlo, definimos la función cuenta.
------------------------------------------------------------------ *}

text {*
---------------------------------------------------------------------
Ejercicio 8. Definir la función
cuenta :: int list ⇒ int ⇒ nat
tal que (cuenta xs y) es el número de veces que aparece el elemento y
en la lista xs. Por ejemplo,
cuenta [1,3,4,3,5] 3 = 2
------------------------------------------------------------------ *}

fun cuenta :: "int list ⇒ int ⇒ nat" where
"cuenta [] y = 0"
| "cuenta (x#xs) y = (if x=y then Suc(cuenta xs y) else cuenta xs y)"

value "cuenta [1,3,4,3,5] 3" -- "= 2"

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que el número de veces que aparece y en
(inserta x xs) es
* uno más el número de veces que aparece en xs, si y = x;
* el número de veces que aparece en xs, si y ≠ x;
------------------------------------------------------------------ *}

-- "La demostración automática es"
lemma cuenta_inserta:
"cuenta (inserta x xs) y =
(if x=y then Suc (cuenta xs y) else cuenta xs y)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que el número de veces que aparece y en
(ordena xs) es el número de veces que aparece en xs.
------------------------------------------------------------------ *}

-- "La demostración automática es"
theorem cuenta_ordena:
"cuenta (ordena xs) y = cuenta xs y"
by (induct xs) (auto simp add: cuenta_inserta)

-- "La demostración estructurada es"
theorem cuenta_ordena_2:
"cuenta (ordena xs) y = cuenta xs y"
proof (induct xs)
show "cuenta (ordena []) y = cuenta [] y" by simp
next
fix x xs
assume HI: "cuenta (ordena xs) y = cuenta xs y"
show "cuenta (ordena (x # xs)) y = cuenta (x # xs) y"
proof (cases "x = y")
assume "x = y"
have "cuenta (ordena (x # xs)) y = cuenta (inserta x (ordena xs)) y" by simp
also have "… = Suc (cuenta (ordena xs) y)" using `x = y` by (simp add: cuenta_inserta)
also have "… = Suc (cuenta xs y)" using HI by simp
also have "… = cuenta (x # xs) y" using `x = y` by simp
finally show "cuenta (ordena (x # xs)) y = cuenta (x # xs) y" by simp
next
assume "x ≠ y"
have "cuenta (ordena (x # xs)) y = cuenta (inserta x (ordena xs)) y" by simp
also have "… = cuenta (ordena xs) y" using `x ≠ y` by (simp add: cuenta_inserta)
also have "… = cuenta xs y" using HI by simp
also have "… = cuenta (x # xs) y" using `x ≠ y` by simp
finally show "cuenta (ordena (x # xs)) y = cuenta (x # xs) y" by simp
qed
qed

end
</source>

Tema 5b: Verificación de la ordenación por mezcla

2018-07-16T15:46:18Z

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

<source lang="isabelle">
header {* T5b: Verificación de la ordenación por mezcla *}

theory T5b_Verificacion_de_la_ordenacion_por_mezcla_sol
imports Main
begin

text {*
En esta relación de ejercicios se define el algoritmo de ordenación de
listas por mezcla y se demuestra que es correcto.
*}

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
menor :: int ⇒ int list ⇒ bool
tal que (menor a xs) se verifica si a es menor o igual que todos los
elementos de xs.Por ejemplo,
menor 2 [3,2,5] = True
menor 2 [3,0,5] = False
------------------------------------------------------------------ *}

fun menor :: "int ⇒ int list ⇒ bool" where
"menor a [] = True"
| "menor a (x#xs) = (a ≤ x ∧ menor a xs)"

value "menor 2 [3,2,5]" -- "= True"
value "menor 2 [3,0,5]" -- "= False"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
ordenada :: int list ⇒ bool
tal que (ordenada xs) se verifica si xs es una lista ordenada de
manera creciente. Por ejemplo,
ordenada [2,3,3,5] = True
ordenada [2,4,3,5] = False
------------------------------------------------------------------ *}

fun ordenada :: "int list ⇒ bool" where
"ordenada [] = True"
| "ordenada (x#xs) = (menor x xs & ordenada xs)"

value "ordenada [2,3,3,5]" -- "= True"
value "ordenada [2,4,3,5]" -- "= False"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
cuenta :: int list => int => nat
tal que (cuenta xs y) es el número de veces que aparece el elemento y
en la lista xs. Por ejemplo,
cuenta [1,3,4,3,5] 3 = 2
------------------------------------------------------------------ *}

fun cuenta :: "int list => int => nat" where
"cuenta [] y = 0"
| "cuenta (x#xs) y = (if x=y then Suc(cuenta xs y) else cuenta xs y)"

value "cuenta [1,3,4,3,5] 3" -- "= 2"

section {* Ordenación por mezcla *}

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
mezcla :: int list ⇒ int list ⇒ int list
tal que (mezcla xs ys) es la lista obtenida mezclando las listas
ordenadas xs e ys. Por ejemplo,
mezcla [1,2,5] [3,5,7] = [1,2,3,5,5,7]
------------------------------------------------------------------ *}

fun mezcla :: "int list ⇒ int list ⇒ int list" where
"mezcla [] ys = ys"
| "mezcla xs [] = xs"
| "mezcla (x # xs) (y # ys) = (if x ≤ y
then x # mezcla xs (y # ys)
else y # mezcla (x # xs) ys)"

value "mezcla [1,2,5] [3,5,7]" -- "= [1,2,3,5,5,7]"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
ordenaM :: int list ⇒ int list
tal que (ordenaM xs) es la lista obtenida ordenando la lista xs
mediante mezclas; es decir, la divide en dos mitades, las ordena y las
mezcla. Por ejemplo,
ordenaM [3,2,5,2] = [2,2,3,5]
------------------------------------------------------------------ *}

fun ordenaM :: "int list ⇒ int list" where
"ordenaM [] = []"
| "ordenaM [x] = [x]"
| "ordenaM xs =
(let mitad = length xs div 2 in
mezcla (ordenaM (take mitad xs))
(ordenaM (drop mitad xs)))"

value "ordenaM [3,2,5,2]" -- "= [2,2,3,5]"

text {*
---------------------------------------------------------------------
Ejercicio 6. Sea x ≤ y. Si y es menor o igual que todos los elementos
de xs, entonces x es menor o igual que todos los elementos de xs
------------------------------------------------------------------ *}

lemma menor_menor:
"x ≤ y ⟹ menor y xs ⟶ menor x xs"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que el número de veces que aparece n en la
mezcla de dos listas es igual a la suma del número de apariciones en
cada una de las listas
------------------------------------------------------------------ *}

lemma cuenta_mezcla:
"cuenta (mezcla xs ys) n = cuenta xs n + cuenta ys n"
by (induct xs ys rule: mezcla.induct) auto

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que si x es menor que todos los elementos de
ys y de zs, entonces también lo es de su mezcla.
------------------------------------------------------------------ *}

lemma menor_mezcla:
assumes "menor x ys"
"menor x zs"
shows "menor x (mezcla ys zs)"
using assms
by (induct ys zs rule: mezcla.induct) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que la mezcla de dos listas ordenadas es una
lista ordenada.
Indicación: Usar los siguientes lemas
· linorder_not_le: (¬ x ≤ y) = (y < x)
· order_less_le: (x < y) = (x ≤ y ∧ x ≠ y)
------------------------------------------------------------------ *}

lemma ordenada_mezcla:
assumes "ordenada xs"
"ordenada ys"
shows "ordenada (mezcla xs ys)"
using assms
by (induct xs ys rule: mezcla.induct)
(auto simp add: menor_mezcla
menor_menor
linorder_not_le
order_less_le)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que si x es mayor que 1, entonces el mínimo de
x y su mitad es menor que x.
Indicación: Usar los siguientes lemas
· min_def: min a b = (if a ≤ b then a else b)
· linorder_not_le: (¬ x ≤ y) = (y < x)
------------------------------------------------------------------ *}

lemma min_mitad:
"1 < x ⟹ min x (x div 2::int) < x"
by (simp add: min_def linorder_not_le)

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si x es mayor que 1, entonces x menos su
mitad es menor que x.
------------------------------------------------------------------ *}

lemma menos_mitad:
"1 < x ⟹ x - x div (2::int) < x"
by arith

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que (ordenaM xs) está ordenada.
------------------------------------------------------------------ *}

theorem ordenada_ordenaM:
"ordenada (ordenaM xs)"
by (induct xs rule: ordenaM.induct)
(auto simp add: ordenada_mezcla)

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar que el número de apariciones de un elemento en
la concatenación de dos listas es la suma del número de apariciones en
cada una.
------------------------------------------------------------------ *}

lemma cuenta_conc:
"cuenta (xs @ ys) x = cuenta xs x + cuenta ys x"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar que las listas xs y (ordenaM xs) tienen los
mismos elementos.
------------------------------------------------------------------ *}

theorem cuenta_ordenaM:
"cuenta (ordenaM xs) x = cuenta xs x"
by (induct xs rule: ordenaM.induct)
(auto simp add: cuenta_mezcla
cuenta_conc [symmetric])

end
</source>

Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL

2018-07-16T15:46:17Z

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

<source lang="isabelle">
header {* Tema 3: Razonamiento sobre programas *}

theory T3_Razonamiento_sobre_programas
imports Main
begin

text {*
En este tema se demuestra con Isabelle las propiedades de los
programas funcionales como se expone en el tema 2a y se demostraron
automáticamente en el tema 2b. A diferencia del tema 2b, ahora
nos fijamos no sólo en el método de demostración sino en la estructura
de la prueba resaltando su semejanza con las del tema 2a. *}

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"
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 {* ---------------------------------------------------------------
Ejemplo 4. (p.6) Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- *}

-- "La demostración detallada es"
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 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 {*
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
*}

-- "La demostración estructurada es"
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

text {*
Nota: La diferencia entre las dos demostraciones es que en los dos
primeros pasos no se explicita la regla de simplificación.
*}

-- "La demostración automática es"
lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

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

text {*
En la demostración anterior se han usado las siguientes reglas:
· inversa.simps(1): inversa [] = []
· inversa.simps(2): inversa (x#xs) = inversa xs @ [x]
· append_Nil: [] @ ys = ys
*}

-- "La demostración estructurada 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 automática es"
lemma "inversa [x] = [x]"
by simp

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

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

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 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 {*
Comentario sobre la demostración anterior
· (induct xs) genera dos subobjetivos:
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
*}

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

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 = [a⇣2]
ys = [a⇣1] *}

text {* ---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

-- "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

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

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

-- "La demostración automática 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 automática es"
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) auto

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

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

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 [1]" -- "= False"

text {* ---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

-- "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
thus "esVacia xs = esVacia (conc xs xs)" by simp
next
case Cons
thus "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 automática es"
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) auto

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

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

text {* ---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

-- "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 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

-- "La demostración automática es"
lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
by (induct xs) auto

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

-- "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

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

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>

Tema 1: Programación funcional en Isabelle

2018-07-16T15:46:17Z

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

<source lang="isabelle">
header {* Tema 1: Programación funcional en Isabelle *}

theory T1
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"

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"

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"

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"

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"

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"

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"

text {* La conjunción de un fórmula verdadera y una falsa es falsa. *}
value "True ∧ False" -- "= False"

text {* La disyunción de una fórmula verdadera y una falsa es
verdadera. *}
value "True ∨ False" -- "= True"

text {* La disyunción de dos fórmulas falsas es falsa. *}
value "False ∨ False" -- "= False"

text {* La negación de una fórmula verdadera es falsa. *}
value "¬True" -- "= False"

text {* Una fórmula falsa implica una fórmula verdadera. *}
value "False ⟶ True" -- "= True"

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"

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"

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 c, b y a es [a,b,c]. *}

value "a#(b#(c#[]))" -- "= [a,b,c]"

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"

text {* (length xs) es la longitud de la lista xs. Por ejemplo, la
longitud de la lista [1,2,3] es 3. *}

value "length [1,2,3]" -- "= 3"

text {* En la sesión 47 de "Isabelle/HOL — Higher-Order Logic"
http://goo.gl/sFsFF 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"

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"

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"

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)"
-- "= 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"

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"

end
</source>

Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL

2018-07-16T15:46:17Z

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

<source lang="isabelle">
header {* Tema 2: Razonamiento automático sobre programas en Isabelle/HOL *}

theory T2_Razonamiento_sobre_programas
imports Main
begin

text {*
En este tema se demuestra con Isabelle las propiedades de los
programas funcionales como se expone en el tema 8 del curso
"Informática" que puede leerse en http://goo.gl/Imvyt *}

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 [4,2,5] = 3
------------------------------------------------------------------- *}

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

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

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

lemma "longitud [4,2,5] = 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 {* ---------------------------------------------------------------
Ejemplo 4. (p.6) Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- *}

lemma "intercambia (intercambia (x,y)) = (x,y)"
by simp

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

lemma "inversa [x] = [x]"
by simp

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

lemma "longitud (repite n x) = n"
by (induct n) auto

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 que puede verse con
thm list.induct
*}

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

lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) auto

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 = [a⇣2]
ys = [a⇣1] *}

text {* ---------------------------------------------------------------
Ejemplo 12. (p. 28) Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

lemma "conc xs [] = xs"
by (induct xs) auto

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

lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) auto

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

lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) auto

section {* Razonamiento por casos *}

text {*
Distinción de casos sobre listas:
· El método de distinción de casos se activa con (cases xs) donde xs
es del tipo lista.
· "case Nil" es una abreviatura de
"assume Nil: xs =[]".
· "case Cons" es una abreviatura de
"fix ? ?? assume Cons: xs = ? # ??"
donde ? y ?? son variables anónimas. *}

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 [1]" -- "= False"

text {* ---------------------------------------------------------------
Ejemplo 18 (p. 39) . Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) auto

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

lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) auto

text {* ---------------------------------------------------------------
Ejemplo 21. (p. 43) Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

-- "La demostración automática es"
corollary "inversaAc xs = inversa xs"
by (simp add: 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)
------------------------------------------------------------------- *}

lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
by (induct xs) auto

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

lemma "longitud (map f xs) = longitud xs"
by (induct xs) auto

section {* Referencias *}

text {*
· J.A. Alonso. "Razonamiento sobre programas" http://goo.gl/R06O3
· G. Hutton. "Programming in Haskell". Cap. 13 "Reasoning about
programms". http://bit.ly/1gMqK0X
· 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". http://bit.ly/1gMqFKI
*}

end
</source>

Relación 8

2018-07-16T15:46:16Z

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

<source lang="isabelle">
header {* R8: Árboles binarios completos *}

theory R8_Arboles_binarios_completos
imports Main
begin

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

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H)"
value "(N (N H H) (N (N H H) H))" --"Este tambien es un arbol segun la definicion del tipo. Sin embargo no es completo."

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

--"diecabmen1 irealetei juaruipav domlloriv marescpla pabflomar"
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N i d) = hojas i + hojas d"

--"julrobrel maresccas4 jaisalmen zoiruicha"
fun hojas_jrr :: "arbol => nat" where
"hojas_jrr H = 1" --"julrobrel: minima diferencia con la anterior"
|"hojas_jrr (N i d) = (hojas_jrr i) + (hojas_jrr d)"

value "hojas_jrr (N (N H H) (N H H))" -- "= 4"

value "hojas (N (N H H) (N H H))" -- "= 4"
value "hojas (N (N H H) (N (N H H) H))" --"= 5" --"julrobrel: la funcion tambien funciona sobre arboles binarios no completos"

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

--"diecabmen1 juaruipav"
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = (if profundidad i > profundidad d then Suc (profundidad i) else Suc (profundidad d))"

--"julrobrel pabflomar"
fun maximo :: "nat => nat => nat" where
"maximo a b = (if a < b then b else a)"

-- "pabflomar"
fun profundidad_pfm :: "arbol => nat" where
"profundidad_pfm H = 0"
| "profundidad_pfm (N i d) = 1 + maximo (profundidad_pfm i) (profundidad_pfm d)"

value "maximo 3 4" -- "=4"

--"julrobrel"
fun profundidad_jrr :: "arbol => nat" where
"profundidad_jrr H = 0"
|"profundidad_jrr (N i d) = Suc (maximo (profundidad_jrr i) (profundidad_jrr d))" --"julrobrel: En realidad al ser arboles completos no deberia hacer falta el maximo"

--"jaisalmen zoiruicha"
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + (if profundidad i > profundidad d then (profundidad i) else (profundidad d) )"

value "profundidad (N (N H H) (N H H))" -- "= 2"
value "profundidad (N (N H H) (N (N H H) H))" -- "= 3" --"julrobrel: profundidad tambien funciona sobre arboles binarios no completos"

value "profundidad_jrr (N (N H H) (N H H))" -- "= 2"
value "profundidad_jrr (N (N H H) (N (N H H) H))" -- "= 3" --"julrobrel: profundidad tambien funciona sobre arboles binarios no completos"

--"irealetei maresccas4 domlloriv marescpla"
--"marescpla: yo he puesto un Suc en vez de un 1+"

fun profundidad3 :: "arbol => nat" where
"profundidad3 (H) = 0"
| "profundidad3 (N ai ad) = 1 + (if (profundidad3 ai > profundidad3 ad) then profundidad3 ai else profundidad3 ad)"

value "profundidad3 (N (N H H) (N H (N H (N H H))))" -- "= 4"

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}

--"diecabmen1, julrobrel irealetei juaruipav maresccas4 domlloriv marescpla pabflomar jaisalmen zoiruicha"
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

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

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

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

--"diecabmen1 irealetei juaruipav maresccas4 domlloriv marescpla pabflomar jaisalmem zoiruicha"
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc f H = True"
| "es_abc f (N i d) = ((es_abc f i) ∧ (es_abc f d) ∧ (f i = f d))"

value "es_abc profundidad ( N (N (N H H) (N H H)) (N (N H H) (N H H)))" -- "true"
value "es_abc profundidad ( N (N (N H H) (N H H)) (N H (N H H)))" -- "false"
value "es_abc profundidad ( N (N (N H H) (N H H)) (N (N H H) H))" -- "false"
value "es_abc profundidad ( N (N H (N H H)) (N H (N H H)))" -- "false"

--"julrobrel"
fun es_abc_jrr:: "nat => arbol => bool" where
"es_abc_jrr 0 H = True"
|"es_abc_jrr (Suc f) H = False"
|"es_abc_jrr 0 (N i d) = False"
|"es_abc_jrr (Suc f) (N i d) = (((es_abc_jrr f i) ∧ (es_abc_jrr f d)) ∧ ((profundidad_jrr i) = (profundidad_jrr d)) ∧ ((profundidad_jrr i) = f))"

value "es_abc_jrr 2 (N (N H H) (N H H))"
value "es_abc_jrr 0 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"
value "es_abc_jrr 1 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"
value "es_abc_jrr 2 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"
value "es_abc_jrr 3 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"

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

value "size (N (N H H) (N H H))"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"
value "size (N (N H H) (N (N H H) H))" --"julrobrel: No es un arbol binario completo"

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

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}
--"julrobrel: en un arbol binario completo la profundidad y las hojas estan relacionadas por la siguiente igualdad (hojas = 2^profundidad)"
--"jaisalmen zoiruicha: el número de hojas es igual a 2 elevado a la profundidad"
lemma "(hojas (abc n))=2^(profundidad (abc n))"
by (induct n) auto

--"irealetei, diecabmen1, maresccas4 domlloriv"
(*irealetei: casi me estalla el cerebro con esta demo, gracias a Marco que me dio una pista hace un par de días sobre que el había usado el assumes. La automática se me queda a medias.*)
lemma 00:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

lemma profundidad_hojas_completo: "es_abc hojas a = es_abc profundidad a"
by (induct a) (auto simp add: 00)

-- "maresccas4: no he sido capaz de terminar la demostración manual"
theorem "es_abc profundidad a = es_abc hojas a" (is "?P a")
proof (induct a)
show "?P H" by simp
next
fix i d
assume H1: "?P i"
assume H2: "?P d"
show "?P (N i d)"
proof (cases)
assume H: "es_abc profundidad (N i d)"
then have "es_abc profundidad (N i d) = (es_abc profundidad i ∧ es_abc profundidad d ∧ profundidad i = profundidad d)" by simp
also have "... = (es_abc hojas i ∧ es_abc hojas d ∧ profundidad i = profundidad d)" using H1 H2 by simp
also have "... = (es_abc hojas i ∧ es_abc hojas d ∧ hojas i = hojas d)" using H by (simp add: 00)
also have "... = es_abc hojas (N i d)" by simp
finally show ?thesis .
next
assume H: "¬ es_abc profundidad (N i d)"
show "?P (N i d)"
proof (cases)
assume I: "(es_abc profundidad i ∧ es_abc profundidad d)"
then have "es_abc profundidad (N i d) = (es_abc profundidad i ∧ es_abc profundidad d ∧ profundidad i = profundidad d)" by simp
also have "...= (profundidad i = profundidad d)" using H I by simp

oops

-- "pabflomar"

lemma "(hojas (abc n))= 2^(profundidad_pfm (abc n))"
proof (induct n)
show " hojas (abc 0) = 2 ^ profundidad_pfm (abc 0)" by simp
next
fix n
assume HI: " hojas (abc n) = 2 ^ profundidad_pfm (abc n)"
then have " hojas (abc (Suc n)) = 2 * hojas (abc n)" by simp
also have "... = 2 * (2 ^ profundidad_pfm (abc n))" using HI by simp
finally show "hojas (abc (Suc n)) = 2 ^ profundidad_pfm (abc (Suc n))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos
---------------------------------------------------------------------
*}
--"julrobrel: la relacion entre hojas y nodos la da la siguiente ecuacion (nodos = hojas -1) o lo que es lo mismo (nodos+1=hojas)"
lemma "Suc(size (abc n))=hojas (abc n)"
by (induct n) auto

-- "irealetei maresccas4 diecabmen1 domlloriv"
(*he conseguido hacer uno!! bieeeeeeeen!!"*)
lemma relaccion_hojas_nodo:"hojas (a) = size (a) + 1"
by (induct a) auto

-- "jaisalmen zoiruicha"
-- "cambios mínimos respecto al anterior, solo los ( )"
lemma relaccion_hojas_nodo:"hojas a = size a + 1"
by (induct a) auto

lemma hojas_size_completo: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: relaccion_hojas_nodo)

lemma "es_abc hojas a = es_abc size a"
proof (induct a)
show "es_abc hojas H = es_abc size H" by simp
next
fix i d
assume HI1:"es_abc hojas i = es_abc size i"
assume HI2:"es_abc hojas d = es_abc size d"
show " es_abc hojas (N i d) = es_abc size (N i d)"
proof -
have "es_abc hojas (N i d) = (es_abc hojas i ∧ es_abc hojas d ∧ hojas i = hojas d)" by simp
also have "... = (es_abc size i ∧ es_abc size d ∧ hojas i = hojas d)" using HI1 HI2 by simp
also have "... = (es_abc size i ∧ es_abc size d ∧ size i = size d)" by (simp add:relaccion_hojas_nodo)
also have "... = es_abc size (N i d)" by simp
finally show ?thesis by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos
---------------------------------------------------------------------
*}
--"julrobrel: la relacion entre la profundidad y el numero de nodos es (nodos+1=2^profundidad)"
lemma "Suc(size (abc n))=2^(profundidad (abc n))"
by (induct n) auto

--"jaisalmen zoiruicha"
lemma "1 + size (abc n) = 2^(profundidad (abc n))"
by (induct n) auto

-- "irealetei: suponía que sería como el 7 pero no sale... por mucho que me pongo a definir lemas. De todos modos dejo donde me he quedado"
lemma 02:
assumes "es_abc size a"
shows "size a + 1 = 2^(profundidad a)"
using assms
by (induct a) auto

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

lemma "es_abc profundidad a = es_abc size a"
by (induct a) (auto simp add:00 02 03) --"He puesto todas la teorías aunque suponía que con 02 sería suficiente"

-- "maresccas4"
(*irealetei: como me he complicado la existencia...*)
theorem "es_abc profundidad a = es_abc size a"
proof -
have "(es_abc profundidad a = es_abc hojas a)" by (simp add: profundidad_hojas_completo)
also have "...= es_abc size a" by (simp add: hojas_size_completo)
finally show ?thesis.
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}
--"julrobrel: para todo lo anterior nos hemos basado en que (abc n) siempre devuelve un arbol binario completo. Habra que demostrarlo..."
lemma profundidad_lemma: "profundidad_jrr (abc n) = n"
by (induct n) auto

--"jaisalmen zoiruicha"
lemma "profundidad (abc n) = n"
by (induct n) auto

lemma "es_abc_jrr n (abc n)"
by (induct n) (auto simp add:profundidad_lemma)

-- "irealetei"
lemma "es_abc profundidad (abc n)" by (induct n) auto
(* irealetei: es raro, hay que hacerlo por induct aunque parece que no usa la HI... pero por cases no se lo traga.
Creo que está mejor la solución de marco, pero la dejo para comentarla.*)
lemma "es_abc profundidad (abc n)"
proof (induct n)
show "es_abc profundidad (abc 0)" by simp
next
fix n
assume " es_abc profundidad (abc n)"
then have "es_abc profundidad (abc (Suc n))= es_abc profundidad (N (abc n) (abc n))" by simp
also have "... = es_abc profundidad (abc n)" by simp
finally show "es_abc profundidad (abc n) ⟹ es_abc profundidad (abc (Suc n))" by simp
qed

-- "maresccas4"
lemma "es_abc profundidad (abc n)"
proof (induct n)
show "es_abc profundidad (abc 0)" by simp
next
fix n
assume HI: "es_abc profundidad (abc n)"
then have "es_abc profundidad (abc (Suc n))= es_abc profundidad (N (abc n) (abc n))" by simp
also have "...= (es_abc profundidad (abc n) ∧ es_abc profundidad (abc n) ∧ profundidad (abc n) = profundidad (abc n))" by simp
finally show "es_abc profundidad (abc (Suc n))" using HI by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es (abc (profundidad a)).
---------------------------------------------------------------------
*}
lemma "(es_abc_jrr (profundidad_jrr a) a) ⟶ a = abc (profundidad_jrr a)"
by (induct a) auto

--"irealetei maresccas4 domlloriv marescpla jaisalmen zoiruicha"
lemma "es_abc profundidad a ⟹ a = abc (profundidad a)" by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}
--"julrobrel"
lemma "es_abc_jrr f t = es_abc_jrr (size t) t"
quickcheck
oops
--"julrobrel: El arbol que es una hoja..."
(*
Quickcheck found a counterexample:

f = Suc 0
t = H

Evaluated terms:
es_abc f t = False
es_abc (size t) t = True
*)

-- "irealetei maresccas4 domlloriv jaisalmen zoiruicha"
lemma "es_abc f a = es_abc size a"
quickcheck
oops

(*f = λx. a
a = N H (N H H)*)

--"marescpla"

fun contraejemplo :: "arbol => nat" where
"contraejemplo H = Suc(0)"|
"contraejemplo (N i d)= Suc 0"

value "es_abc contraejemplo (N (N H H) H)"
value "es_abc size (N (N H H) H)"

end
</source>

Relación 9

2018-07-16T15:46:16Z

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

<source lang="isabelle">
header {* R9: Deducción natural proposicional (1) *}

theory R9
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es lemas usando sólo las reglas básicas
de deducción natural de la lógica proposicional.

Las reglas básicas de la deducción natural necesarias son las1
siguientes:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· notnotD: ¬¬P ⟹ P
· notnotI: P ⟹ ¬¬P
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
---------------------------------------------------------------------
*}

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 ⟶ r) ⊢ q ⟶ (p ⟶ r)
------------------------------------------------------------------ *}

-- "irealetei,julrobrel, pabflomar juaruipav domlloriv jaisalmen zoiruicha"
lemma ej1_auto:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
using assms
by auto

lemma ej1:
assumes 1:"p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{assume 2:"q"
{assume 3:"p"
have 4:"q⟶r" using 1 3 by (rule mp)
have "r" using 4 2 by (rule mp)}
then have "p⟶r" by (rule impI)}
then show "q⟶(p⟶r)" by (rule impI)
qed

-- "diecabmen1"
lemma Ejercicio_1:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{ assume "q"
{ assume "p"
with assms have "q ⟶ r" ..
then have "r" using `q` .. }
then have "p ⟶ r" .. }
then show "q ⟶ (p ⟶ r)" ..
qed

-- "maresccas4"
lemma
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof
assume "q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" ..
thus "r" using `q`..
qed
qed

--"marescpla"

lemma 01:
assumes "p⟶(q⟶r)"
shows "q ⟶ (p⟶r)"
proof-
{assume 1: "q"
{assume 2: "p"
have "q⟶r" using assms(1) 2 by (rule mp)
then have "r" using 1 by (rule mp)}
then have "p⟶r" ..}
then show "q ⟶(p⟶r)" by (rule impI)
qed

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

-- "irealetei,julrobrel, pabflomar, domlloriv jaisalmen zoiruicha"
lemma ej2_auto:
assumes " p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
using assms by auto

lemma ej2:
assumes 1:" p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof -
{assume 2:"(p ⟶ q)"
{assume 3:"p"
have 4:"q" using 2 3 by (rule mp)
have 5:"q⟶r" using 1 3 by (rule mp)
have "r" using 5 4 by (rule mp)}
then have "p⟶r" by (rule impI)}
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)
qed

-- "diecabmen1"
lemma Ejercicio_2:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" ..
have "q ⟶ r" using assms `p` ..
then show "r" using `q` ..
qed
qed

-- "maresccas4"
lemma
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
have "q" using `p ⟶ q` `p` ..
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` ..
show "r" using `q ⟶ r` `q` ..
qed
qed

--"marescpla"

lemma 02:
assumes "p⟶(q⟶r)"
shows "(p⟶q) ⟶ (p⟶r)"
proof-
{assume 1: "p⟶q"
{assume 2: "p"
have "q" using 1 2 by (rule mp)
have "q⟶r" using assms(1) 2 by (rule mp)
then have "r" using `q` by (rule mp)}
then have "p⟶r"..}
then show "(p⟶q) ⟶ (p⟶r)" ..
qed

-- "juaruipav"
lemma ej2-jua:
assumes 1: " p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume 2: " p ⟶ q"
show "p ⟶ r"
proof
assume 3: "p"
have 4: "q" using 2 3 by (rule mp)
have 5: "q⟶r" using 1 3 by (rule mp)
show "r" using 5 4 by (rule mp)
qed
qed

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

-- "irealetei, domlloriv, pabflomar jaisalmen zoiruicha"
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
by auto

lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof -
{ assume 1:"(p⟶(q⟶r))"
{assume 3:"p⟶q"
{assume 4:"p"
have 5: "q⟶r" using 1 4 by (rule mp)
have 6:"q" using 3 4 by (rule mp)
have "r" using 5 6 by (rule mp)}
then have "p⟶r" by (rule impI)}
then have "(p⟶q)⟶p⟶r" by (rule impI)}
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI)
qed

-- "diecabmen1, maresccas4"
lemma Ejercicio_3:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ q ⟶ r"
show "(p ⟶ q) ⟶ p ⟶ r"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" ..
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..
then show "r" using `q` ..
qed
qed
qed

--"julrobrel"
lemma ejer_3_auto:
shows "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
by auto

thm ej2_auto

lemma ejer_3_detalle:
shows "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof -
show "(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))" using ej2_auto by (rule impI)
qed

--"marescpla"
lemma 03:
"(p ⟶ (q ⟶ r))⟶((p ⟶ q) ⟶ (p ⟶ r))"
proof-
{assume 1: "(p ⟶ (q ⟶ r))"
{assume 2: "(p ⟶ q)"
{assume 3: "p"
have "q" using 2 3 by (rule mp)
have "q ⟶r" using 1 3 by (rule mp)
then have "r" using `q` by (rule mp)}
then have"p⟶r" by (rule impI)}
then have "((p ⟶ q) ⟶ (p ⟶ r))" by (rule impI)}
then show "(p ⟶ (q ⟶ r))⟶((p ⟶ q) ⟶ (p ⟶ r))" by (rule impI)
qed

--"juaruipav"

lemma ej3-jua: " (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume 1: "p ⟶ q ⟶ r"
show "(p ⟶ q) ⟶ p ⟶ r"
proof
assume 2: "p⟶q"
show "p ⟶ r"
proof
assume 3: "p"
have 4:"q" using 2 3 ..
have 5: "q⟶r" using 1 3 by (rule mp)
show "r" using 5 4 ..
qed
qed
qed

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

-- "irealetei,julrobrel, domlloriv jaisalmen zoiruicha"
lemma ej4_auto:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
using assms by auto

-- "maresccas4"
lemma
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
hence "p ⟶ q" ..
show "r" using `(p ⟶ q) ⟶ r` `p ⟶ q` ..
qed
qed

-- "juaruipav irealetei"
lemma ej4-jua:
assumes 1: "(p ⟶ q) ⟶ r"
shows " p ⟶ (q ⟶ r)"
proof
assume 2: "p"
show "q⟶r"
proof
assume 3: "q"
have 4: "p⟶q" using 3 by (rule impI)
show "r" using 1 4 by (rule mp)
qed
qed

--"marescpla"
lemma 04:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof-
{assume 1: "p"
{assume 2: "q"
then have "r" using 1 2 assms by simp}
then have "q⟶r" by (rule impI)}
then show "p⟶ (q ⟶ r)" by (rule impI)
qed

section {* Conjunciones *}

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

-- "irealetei,julrobrel, domlloriv jaisalmen zoiruicha"
lemma ej5_auto:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
using assms by auto

lemma ej5:
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof -
{assume 2:"p"
have 3: "p⟶q" using 1 by (rule conjunct1)
have 4: "p⟶r" using 1 by (rule conjunct2)
have 5: "q" using 3 2 by (rule mp)
have 6: "r" using 4 2 by (rule mp)
have "q ∧ r" using 5 6 by (rule conjI)}
then show "p ⟶ q ∧ r" by (rule impI)
qed

-- "diecabmen1, maresccas4"
lemma Ejercicio_5:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume "p"
have "(p ⟶ q)" using assms ..
then have "q" using `p` ..
have "(p ⟶ r)" using assms ..
then have "r" using `p` ..
with `q` show "q ∧ r" ..
qed

--"julrobrel, pabflomar, marescpla(Pero usando assms en vez de la etiqueta 0)"
lemma ejer_5_detalle:
assumes 0:"(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof -
have 1:"p⟶q" using 0 by (rule conjunct1)
have 2:"p⟶r" using 0 by (rule conjunct2)
{assume 3:"p"
have 4:"q" using 1 3 by (rule mp)
have 5:"r" using 2 3 by (rule mp)
have 6:"q ∧ r" using 4 5 by (rule conjI)
}then show "p ⟶ q ∧ r" by (rule impI)
qed

-- "juaruipav"
lemma ej5-jua:
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume 2: "p"
have 3: "(p ⟶ q)" using 1 by (rule conjunct1)
have 4:"(p ⟶ r)" using 1 by (rule conjunct2)
have 5:"q" using 3 2 by (rule mp)
have 6:"r" using 4 2 by (rule mp)
show "q∧r" using 5 6 by (rule conjI)
qed

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

-- "irealetei,julrobrel jaisalmen zoiruicha"
lemma ej6_auto:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
using assms by auto
-- "pabflomar"
{* Me he peleado un buen rato intentando asumiendo solo una vez p. Al mirar el wiki y tal vi esta versión que hace lo que yo quería hacer usando sólo una ves una asumción. ¿Cómo se hace?
*}
lemma ej6:
assumes 1:"p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof -
{assume 2:"p"
have 3:"q∧r" using 1 2 by (rule mp)
have "q" using 3 by (rule conjunct1)}
then have 4:"p⟶q" by (rule impI)
{assume 5:"p"
have 6:"q∧r" using 1 5 by (rule mp)
have "r" using 6 by (rule conjunct2)}
then have 5:"p⟶r" by (rule impI)
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)
qed

-- "diecabmen1, maresccas4, domlloriv"
lemma Ejercicio_6:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
{assume "p"
with assms have "q ∧ r" ..
then have "q" ..}
then show "p ⟶ q" ..
{assume "p"
with assms have "q ∧ r" ..
then have "r" ..}
then show "p ⟶ r" ..
qed

--"juaruipav"
lemma ej6-jua:
assumes 1: " p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
{assume 2: "p"
have 3:"q∧r" using 1 2 by (rule mp)
have "q" using 3 by (rule conjunct1)}
then show "p⟶q" ..
next
{assume 5: "p"
have 6:"q∧r" using 1 5 by (rule mp)
have "r" using 6 by (rule conjunct2)}
then show "p⟶r" ..
qed

--"marescpla"
lemma 06:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof-
{assume "p"
with assms have "q ∧ r" by (rule mp)
then have "q" by (rule conjunct1)}
then have C: "p⟶q" by (rule impI)
{assume "p"
with assms have "q ∧ r" by (rule mp)
have "r" using `q ∧ r` by (rule conjunct2)}
then have "p ⟶ r" by (rule impI)
with C show "(p ⟶ q) ∧ (p ⟶ r)" by (rule conjI)
qed

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

-- "irealetei,julrobrel, pabflomar, domlloriv jaisalmen, zoiruicha"
lemma ej7_auto:
assumes " p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
using assms by auto

lemma ej7:
assumes 1:" p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof -
have 2:"p" using 1 by (rule conjunct1)
have 3:"q⟶r" using 1 by (rule conjunct2)
{assume 4:"p⟶q"
have 5:"q" using 4 2 by (rule mp)
have "r" using 3 5 by (rule mp)}
then show "(p⟶q)⟶r" by (rule impI)
qed

-- "diecabmen1, maresccas4"
lemma Ejercicio_7:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
assume "p ⟶ q"
have "p" using assms ..
with `p ⟶ q` have "q" ..
have "q ⟶ r" using assms ..
then show "r" using `q` ..
qed

-- "juaruipav"
lemma ej7:
assumes 1: " p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
assume 2: " p ⟶ q "
have 3:"p" using 1 by (rule conjunct1)
have 4:"q⟶r" using 1 by (rule conjunct2)
have 5:"q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed

--"marescpla"

lemma 07:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof-
{assume H: "(p ⟶ q)"
have "p" using assms by (rule conjunct1)
with H have "q" by (rule mp)
have "q⟶r" using assms by (rule conjunct2)
then have "r" using `q` by (rule mp)}
then show "(p ⟶ q) ⟶ r" by (rule impI)
qed

section {* Disyunciones *}

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

-- "irealetei diecabmen1, julrobrel, jaisalmen, zoiruicha"
lemma ej8_auto:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
using assms by auto

lemma ej8:
assumes 1:"q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof -
{assume 2:"p ∨ q"
moreover
{assume "p"
then have "p ∨ r" by (rule disjI1)}
moreover
{assume 3:"q"
have "r" using 1 3 by (rule mp)
then have "p ∨ r" by (rule disjI2)}
ultimately have "p ∨ r" by (rule disjE)}
then show "p ∨ q ⟶ p ∨ r" by (rule impI)
qed

--"julrobrel: no estoy seguro de que esto esté bien"
lemma ejer_8_detallado2:
assumes 0:"q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (cases)
assume "¬p"
show "p ∨ q ⟶ p ∨ r" using 0 by simp
next
assume "¬¬p"
show "p ∨ q ⟶ p ∨ r" using 0 by simp
qed

-- "maresccas4"
lemma
assumes "q ⟶ r"
shows "(p ∨ q) ⟶ (p ∨ r)"
proof
assume "p ∨ q"
thus "p ∨ r"
proof
{ assume "p"
thus "p ∨ r" .. }
next
{ assume "q"
have "r" using assms `q` ..
thus "p ∨ r" .. }
qed
qed

--"juaruipav: Si quito el moreover no pasa nada.. ¿y eso? tengo dos objetivos en proof"
lemma ej8:
assumes 1: " q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume 2:"p ∨ q"
thus " p ∨ r"
proof
{assume 3: "p"
then show "p ∨ r" ..}
moreover
{ assume 4: "q"
have "r" using 1 4 by (rule mp)
then show "p ∨ r" ..}
qed
qed

--"marescpla"

lemma 08:
assumes "q⟶r"
shows "p ∨ q ⟶ p ∨ r"
proof-
{assume 1: "p ∨ q"
{assume "p"
then have "p ∨ r" by (rule disjI1)}
then have 2: "p⟹p ∨ r" by simp
{assume q
with assms have "r" by (rule mp)
then have "p ∨ r" by (rule disjI2)}
then have 3: "q⟹p ∨ r" by simp
have "p ∨ q ⟹ p ∨ r" using 1 2 3 by (rule disjE)}
then show "p ∨ q ⟶ p ∨ r" by (rule impI)
qed

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

-- "irealetei diecabmen1, julrobrel, domlloriv, jaisamlem, zoiruicha"
lemma ej9_auto:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
using assms by auto

lemma ej9:
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof -
{assume "p ∨ q "
moreover
{assume 2:"p"
have 3:"(p ⟶ r)" using 1 by (rule conjunct1)
have "r" using 3 2 by (rule mp)}
moreover
{assume 4:"q"
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)
have "r" using 5 4 by (rule mp)}
ultimately have "r" ..}
then show "p ∨ q ⟶ r" by (rule impI)
qed

lemma ejer_9_detalle:
assumes 0:"(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof -
{assume 1:"p∨q"
moreover
{assume 2:"p"
have 3:"p⟶r" using 0 by (rule conjunct1)
have 4:"r" using 3 2 by (rule mp)}
moreover
{assume 5:"q"
have 6:"q⟶r" using 0 by (rule conjunct2)
have 7:"r" using 6 5 by (rule mp)}
ultimately have 8:"r" by (rule disjE)}
then show "p ∨ q ⟶ r" by (rule impI)
qed

-- "maresccas4"
lemma
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume "p ∨ q"
thus "r"
proof
{ assume "p"
have "p ⟶ r" using assms ..
thus "r" using `p` ..}
next
{ assume "q"
have "q ⟶ r" using assms ..
thus "r" using `q`..}
qed
qed

--"juaruipav"
lemma ej9:
assumes 1: "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume 2: "p ∨ q"
thus "r"
proof
{assume 3: "p"
have 4: "p⟶r" using 1 by (rule conjunct1)
show "r" using 4 3 by (rule mp)}
moreover
{assume 5: "q"
have 6: "q⟶r" using 1 by (rule conjunct2)
show "r" using 6 5 by (rule mp)}
qed
qed

--"marescpla"
lemma 09:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof-
have "p⟶r" using assms by (rule conjunct1)
have "q ⟶ r" using assms by (rule conjunct2)
{assume 1: "p ∨ q"
{assume "p"
with `p⟶r` have "r" by (rule mp)}
then have 2: "p⟹r" by simp
{assume "q"
with `q⟶r` have "r" by (rule mp)}
then have 3: "q⟹r" by simp
have "p ∨ q ⟹ r" using 1 2 3 by (rule disjE)}
then show "p ∨ q ⟶ r" by (rule impI)
qed

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

-- "irealetei diecabmen1, julrobrel, domlloriv, jaisalmen zoiruicha"
lemma ej10_auto:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
using assms by auto

lemma ej10:
assumes 1:"p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof -
{assume 2:"p"
have 3:"p∨q" using 2 by (rule disjI1)
have "r" using 1 3 by (rule mp)}
then have 4:"p⟶r" by (rule impI)
{assume 5:"q"
have 6:"p∨q" using 5 by (rule disjI2)
have 7:"r" using 1 6 by (rule mp)}
then have 8:"q⟶r" by (rule impI)
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)
qed

-- "maresccas4"
lemma
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
{ assume "p"
have "p ∨ q" using `p` ..
have "r" using assms `p ∨ q` ..}
then show "p ⟶ r" ..
next
{ assume "q"
have "p ∨ q" using `q` ..
have "r" using assms `p ∨ q` ..}
thus "q ⟶ r" ..
qed

--"juaruipav, pabflomar"
lemma ej10:
assumes 1:" p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
{assume 2 :"p"
have 3: "p ∨ q" using 2 by (rule disjI1)
have 4: "r" using 1 3 by (rule mp)}
then show "p⟶r" ..
moreover
{assume 5 :"q"
have 6: "p ∨ q" using 5 by (rule disjI2)
have 7: "r" using 1 6 by (rule mp)}
then show "q⟶r" ..
qed

--"marescpla"
lemma 10:
assumes "p ∨ q ⟶ r"
shows"(p ⟶ r) ∧ (q ⟶ r)"
proof-
{assume "p"
then have "r" using assms by simp}
then have 1: "p⟶r" by (rule impI)
{assume "q"
then have "r" using assms by simp}
then have 2: "q⟶r" by (rule impI)
show "(p ⟶ r) ∧ (q ⟶ r)" using 1 2 by (rule conjI)
qed

end
</source>

Relación 6

2018-07-16T15:46:15Z

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

<source lang="isabelle">
header {* R6: Sustitución, inversión y eliminación *}

theory R6
imports Main
begin

section {* Sustitución, inversión y eliminación *}

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
sust :: "'a ⇒ 'a ⇒ 'a list ⇒ 'a list"
tal que (sust x y zs) es la lista obtenida sustituyendo cada
occurrencia de x por y en la lista zs. Por ejemplo,
sust (1::nat) 2 [1,2,3,4,1,2,3,4] = [2,2,3,4,2,2,3,4]
---------------------------------------------------------------------
*}

(* pabflomar: Hola, son las 03:37 y por fin funciona el wiki. No he podido copiar ni una sola solución. :@ *)

-- "maresccas4 domlloriv diecabmen1 irealetei juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

fun sust :: "'a ⇒ 'a ⇒ 'a list ⇒ 'a list" where
"sust x y [] = []"
| "sust x y (z#zs) = (if z=x then y#sust x y zs else z#sust x y zs)"

value "sust (1::nat) 2 [1,2,3,4,1,2,3,4]" -- "[2,2,3,4,2,2,3,4]"

text {*
---------------------------------------------------------------------
Ejercicio 2.1. Demostrar o refutar automáticamente
sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv diecabmen1 irealetei juaruipav pabflomar marescpla jaisalmen zoiruicha"

lemma
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
by (induct xs) auto

-- "julrobrel: usando apply, por probar"
lemma
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
apply (induct_tac xs)
apply (auto)
done

text {*
---------------------------------------------------------------------
Ejercicio 2.2. Demostrar o refutar detalladamente
sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
---------------------------------------------------------------------
*}

-- "maresccas4 juaruipav domlloriv marescpla"

lemma sust_append:
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)" (is "?P x y xs ys")
proof (induct xs)
show "?P x y [] ys" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x y xs ys "
show "?P x y (a#xs) ys"
proof cases
assume C1: "a=x"
then have "sust x y ((a#xs)@ys) = y # sust x y (xs@ys)" by simp
also have "... = (y # sust x y xs) @ sust x y ys" using HI by simp
also have "... = sust x y (a#xs) @ sust x y ys" using C1 by simp
finally show "?P x y (a#xs) ys" by simp
next
assume C2: "a≠x"
then have "sust x y ((a#xs)@ys) = a # sust x y (xs@ys)" by simp
also have "... = (a # sust x y xs) @ sust x y ys" using HI by simp
also have "... = sust x y (a#xs) @ sust x y ys" using C2 by simp
finally show "?P x y (a#xs) ys" by simp
qed
qed

-- "diecabmen1 misma solución solamente quito el último also have para evitar redundar con finally"
-- "jaisalmen zoiruicha"
lemma sust_append2:
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)" (is "?P x y xs ys")
proof (induct xs)
show "?P x y [] ys" by simp
next
fix a xs
assume HI: "?P x y xs ys"
show "?P x y (a#xs) ys"
proof (cases)
assume C1:"a=x"
then have "sust x y ((a#xs)@ys) = y#sust x y (xs@ys)" by simp
also have "… = y # (sust x y xs)@(sust x y ys)" using HI by simp
finally show"?P x y (a#xs) ys" using C1 by simp
next
assume C2: "a≠x"
then have "sust x y ((a#xs)@ys) = a # sust x y (xs@ys)" by simp
also have "… = a # (sust x y xs)@(sust x y ys)" using HI by simp
finally show"?P x y (a#xs) ys" using C2 by simp
qed
qed

(*pabflomar: 100% de acuerdo con Irene. *)
-- "irealetei me gusta más sin abreviar "
-- "pabflomar"
lemma sust_append3:
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
proof (induction xs)
show "sust x y ([] @ ys) = sust x y [] @ sust x y ys" by simp
next
fix xs a
assume HI:"sust x y (xs @ ys) = sust x y xs @ sust x y ys"
show "sust x y ((a # xs) @ ys) = sust x y (a # xs) @ sust x y ys"
proof (cases)
assume A: "x=a"
then have "sust x y (a # xs @ ys) = y # sust x y (xs @ ys)" by simp
also have "... = (y # sust x y xs) @ sust x y ys" using HI by simp
also have "...= sust x y (a # xs) @ sust x y ys" using A by simp
finally show "sust x y ((a # xs) @ ys) = sust x y (a # xs) @ sust x y ys" by simp
next
assume A: "x≠a"
then have "sust x y ((a # xs) @ ys) = a # sust x y (xs @ ys)" by simp
also have "...= (a # sust x y xs) @ sust x y ys" using HI by simp
also have "...= sust x y (a#xs) @ sust x y ys" using A by simp
finally show "sust x y ((a # xs) @ ys) = sust x y (a#xs) @ sust x y ys" by simp
qed
qed

(* Juaruipav: Yo no llamaría a las dos hipótesis iguales, aunque no haya conflictos*)

-- "julrobrel"
lemma sust_append_jrr:
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
proof (induct xs)
show "sust x y ([] @ ys) = sust x y [] @ sust x y ys" by simp
next
fix a xs
assume HI:"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
show "sust x y ((a # xs) @ ys) = sust x y (a # xs) @ sust x y ys"
proof (cases)
assume C1: "x=a"
then have "sust x y ((a # xs) @ ys) = y # sust x y (xs @ ys)" by simp
also have "...=y # (sust x y xs)@(sust x y ys)" using HI by simp
also have "...=(sust x y (x#xs))@(sust x y ys)" by simp
also have "...=(sust x y (a#xs))@(sust x y ys)" using C1 by simp
finally show "sust x y ((a # xs) @ ys) = sust x y (a # xs) @ sust x y ys" by simp
next
assume C2: "¬(x=a)"
then have "sust x y ((a # xs) @ ys) = a # sust x y (xs@ys)" by simp
also have "...=a # (sust x y xs)@(sust x y ys)" using HI by simp
also have "...=sust x y (a#xs) @ sust x y ys" using C2 by simp
finally show "sust x y ((a # xs) @ ys) = sust x y (a # xs) @ sust x y ys" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 3.1. Demostrar o refutar automáticamente
rev (sust x y zs) = sust x y (rev zs)
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 irealetei juaruipav domlloriv pabflomar marescpla jaisalmen zoiruicha"
(*domllriv -> Me apunto a este pero a mi no me funciona. Fall add:sust_append*)

lemma
"rev(sust x y zs) = sust x y (rev zs)" (is "?P x y zs")
by (induct zs) (auto simp add:sust_append)

--"julrobrel: por probar otra vez"
lemma
"rev(sust x y zs) = sust x y (rev zs)"
apply (induct_tac zs)
apply (simp_all add: sust_append)
done

text {*
---------------------------------------------------------------------
Ejercicio 3.2. Demostrar o refutar detalladamente
rev (sust x y zs) = sust x y (rev zs)
---------------------------------------------------------------------
*}

-- "maresccas4"
-- "jaisalmen zoiruicha"
(* jaisalmen: la inducción es sobre los elementos de zs*)

lemma rev_sust:
"rev(sust x y zs) = sust x y (rev zs)" (is "?P x y zs")
proof (induct zs)
show "?P x y []" by simp
next
fix z :: "'a"
fix zs :: "'a list"
assume HI: "?P x y zs"
show "?P x y (z#zs)"
proof cases
assume C1: "z=x"
then have "rev(sust x y (z#zs)) = rev(y # (sust x y zs))" by simp
also have "... = rev (sust x y zs) @ [y]" by (simp only: rev.simps(2))
also have "... = sust x y (rev zs) @ [y]" using HI by simp
also have "... = sust x y (rev (z#zs))" using C1 by (simp add:sust_append)
finally show "?P x y (z#zs)" by simp
next
assume C2: "z≠x"
then have "rev(sust x y (z#zs)) = rev(z # (sust x y zs))" by simp
also have "... = rev (sust x y zs) @ [z]" by (simp only: rev.simps(2))
also have "... = sust x y (rev zs) @ [z]" using HI by simp
also have "... = sust x y (rev (z#zs))" using C2 by (simp add:sust_append)
finally show "?P x y (z#zs)" by simp
qed
qed

-- "diecabmen1"
lemma rev_sust2:
"rev(sust x y zs) = sust x y (rev zs)" (is "?P x y zs")
proof (induct zs)
show "?P x y []" by simp
next
fix a zs
assume HI: "?P x y zs"
show "?P x y (a#zs)"
proof cases
assume C1:"x=a"
then have "rev(sust x y (a#zs)) = rev(y # sust x y zs)" by simp
also have "… = rev(sust x y zs) @ [y]" by simp
also have "… = sust x y (rev zs) @ [y]" using HI by simp
finally show "?P x y (a#zs)" using C1 by (simp add:sust_append2)
next
assume C2: "x≠a"
then have "rev(sust x y (a#zs)) = rev(a # sust x y zs)" by simp
also have "… = rev(sust x y zs) @ [a]" by simp
also have "… = sust x y (rev zs) @ [a]" using HI by simp
finally show "?P x y (a#zs)" using C2 by (simp add:sust_append2)
qed
qed

-- "irealetei pabflomar"
lemma rev_sust3:
"rev(sust x y zs) = sust x y (rev zs)"
proof (induct zs)
show "rev (sust x y []) = sust x y (rev [])" by simp
next
fix a zs
assume HI:" rev (sust x y zs) = sust x y (rev zs)"
show "rev (sust x y (a # zs)) = sust x y (rev (a # zs))"
proof (cases)
assume A1:"x=a"
then have "rev (sust x y (a # zs))= rev(y#sust x y zs)" by simp
also have "... = (rev(sust x y zs)@[y])" by simp
also have "...=sust x y (rev zs)@[y]" using HI by simp
also have "...=sust x y (rev(a # zs))" using A1 by (simp add:sust_append)
finally show "rev (sust x y (a # zs))=sust x y (rev(a # zs))" by simp
next
assume A2:"x≠a"
then have "rev (sust x y (a # zs))= rev(a#sust x y zs)" by simp
also have "... = (rev(sust x y zs)@[a])" by simp
also have "...=sust x y (rev zs)@[a]" using HI by simp
also have "...=sust x y (rev(a # zs))" using A2 by (simp add:sust_append)
finally show "rev (sust x y (a # zs))=sust x y (rev(a # zs))" by simp
qed
qed

--"juaruipav domlloriv marescpla"
lemma rev_sust:
"rev(sust x y zs) = sust x y (rev zs)"
proof (induct zs)
show "rev (sust x y []) = sust x y (rev [])" by simp
next
fix a zs
assume HI:" rev (sust x y zs) = sust x y (rev zs)"
show " rev (sust x y (a # zs)) = sust x y (rev (a # zs))"
proof(cases)
assume C1: "a=x"
then have "rev( sust x y (a #zs))= rev( y# sust x y zs)" by simp
also have "...= rev(sust x y zs) @ [y]" by (simp only: rev.simps(2))
also have "...= sust x y (rev zs)@ [y]" using HI by simp
also have "...= (sust x y (rev zs)) @ (sust x y [a])" using C1 by (simp add:sust_append)
also have "... = sust x y (rev zs@[a])" by (simp add:sust_append)
also have "...=sust x y (rev (a#zs))" by (simp only: rev.simps(2))
finally show ?thesis by simp
next
assume C2: "a≠x"
then have "rev( sust x y (a #zs))= rev( x# sust x y zs)" by simp
also have "...= rev(sust x y zs) @ [x]" by (simp only: rev.simps(2))
also have "...= sust x y (rev zs)@ [x]" using HI by simp
also have "...= (sust x y (rev zs)) @ (sust x y [a])" using C2 by (simp add:sust_append)
also have "... = sust x y (rev zs@[a])" by (simp add:sust_append)
also have "...=sust x y (rev (a#zs))" by (simp only: rev.simps(2))
finally show ?thesis by simp
qed
qed

oops --"julrobrel: lo he puesto para comprobar mi edicion"

--"julrobrel"
lemma rev_sust_jrr:
"rev(sust x y zs) = sust x y (rev zs)"
proof (induct zs)
show "rev (sust x y []) = sust x y (rev [])" by simp
next
fix a zs
assume HI:"rev(sust x y zs) = sust x y (rev zs)"
show "rev (sust x y (a # zs)) = sust x y (rev (a # zs))"
proof (cases)
assume C1: "x=a"
then have "rev (sust x y (a # zs)) = rev (y # sust x y zs)" by simp
also have "...=rev (sust x y zs) @ [y]" by simp
also have "...=sust x y (rev zs) @ [y]" using HI by simp
also have "...=sust x y (rev zs) @ sust x y [x]" by simp
also have "...=sust x y ((rev zs)@[x])" by (simp add:sust_append_jrr)
also have "...=sust x y (rev (x#zs))" by simp
also have "...=sust x y (rev (a#zs))" using C1 by simp
finally show "rev (sust x y (a # zs)) = sust x y (rev (a # zs))" .
next
assume C2: "¬(x=a)"
then have "rev (sust x y (a # zs)) = rev (a # sust x y zs)" by simp
also have "...= rev(sust x y zs)@[a]" by simp
also have "...= sust x y (rev zs)@[a]" using HI by simp
also have "...= sust x y (rev (a#zs))" using C2 by (simp add:sust_append_jrr)
finally show "rev (sust x y (a # zs)) = sust x y (rev (a # zs))" .
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar o refutar:
sust x y (sust u v zs) = sust u v (sust x y zs)
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv diecabmen1 irealetei juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

lemma
"sust x y (sust u v zs) = sust u v (sust x y zs)"
quickcheck
oops
(* Contraejemplo:
x = a⇣1
y = a⇣2
u = a⇣2
v = a⇣1
zs = [a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 5. Demostrar o refutar:
sust y z (sust x y zs) = sust x z zs
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv diecabmen1 irealetei juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

lemma
"sust y z (sust x y zs) = sust x z zs"
quickcheck
oops
(* Contraejemplo
y = a⇣1
z = a⇣2
x = a⇣2
zs = [a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 6. Definir la función
borra :: "'a ⇒ 'a list ⇒ 'a list"
tal que (borra x ys) es la lista obtenida borrando la primera
ocurrencia del elemento x en la lista ys. Por ejemplo,
borra (2::nat) [1,2,3,2] = [1,3,2]

Nota: La función borra es equivalente a la predefinida remove1.
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv diecabmen1 irealetei juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

fun borra :: "'a ⇒ 'a list ⇒ 'a list" where
"borra x [] = []"
| "borra x (y#ys) = (if x=y then ys else y # borra x ys)"

value " borra (2::nat) [1,2,3,2]"--"[1,3,2]"

text {*
---------------------------------------------------------------------
Ejercicio 7. Definir la función
borraTodas :: "'a ⇒ 'a list ⇒ 'a list"
tal que (borraTodas x ys) es la lista obtenida borrando todas las
ocurrencias del elemento x en la lista ys. Por ejemplo,
borraTodas (2::nat) [1,2,3,2] = [1,3]
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv irealetei diecabmen1 juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

fun borraTodas :: "'a ⇒ 'a list ⇒ 'a list" where
"borraTodas x [] = []"
| "borraTodas x (y#ys) = (if x=y then borraTodas x ys else y # borraTodas x ys)"

value "borraTodas (2::nat) [1,2,3,2]"--"[1,3]"

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
borra x (borraTodas x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv irealetei diecabmen1 juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

lemma
"borra x (borraTodas x xs) = borraTodas x xs"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 8.2. Demostrar o refutar detalladamente
borra x (borraTodas x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 domlloriv agrego nombre a lemma para ejercicio 12.1 marescpla"

lemma borra_borraTodas:
"borra x (borraTodas x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borra x (borraTodas x (a#xs)) = borra x (borraTodas x xs)" by simp
also have "... = borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borra x (borraTodas x (a#xs)) = borra x (a # borraTodas x xs)" by simp
also have "... = a # borra x (borraTodas x xs)" using C2 by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

-- "irealetei pabflomar"
lemma borrax_BorraTodasx_xs:
"borra x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show "borra x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI:"borra x (borraTodas x xs) = borraTodas x xs"
show "borra x (borraTodas x (a # xs)) = borraTodas x (a # xs)"
proof (cases)
assume A1:"x=a"
then have "borra x (borraTodas x (a # xs)) = borra x (borraTodas x xs)" by simp
also have "...=borraTodas x xs" using HI by simp
finally show "borra x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using A1 by simp
next
assume A2:"x≠a"
then have "borra x (borraTodas x (a # xs)) = borra x (a#(borraTodas x xs))" by simp
also have "...=a # borra x (borraTodas x xs)" using A2 by simp
also have "...=a # borraTodas x xs" using HI by simp
finally show "borra x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using A2 by simp
qed
qed

--" juaruipav"

lemma borradora:
"borra x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show " borra x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI: " borra x (borraTodas x xs) = borraTodas x xs"
show " borra x (borraTodas x (a # xs)) = borraTodas x (a # xs)"
proof(cases)
assume C1: "x=a"
show " borra x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using HI using C1 by simp
next
assume C2: "x≠a"
show " borra x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using HI using C2 by simp
qed
qed

--"julrobrel"
lemma
"borra x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show "borra x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI: "borra x (borraTodas x xs) = borraTodas x xs"
show "borra x (borraTodas x (a#xs)) = borraTodas x (a#xs)"
proof (cases)
assume C1:"x=a"
then have "borra x (borraTodas x (a#xs))=borra x (borraTodas x xs)" by simp
also have "...=borraTodas x xs" using HI by simp
finally show "borra x (borraTodas x (a#xs)) = borraTodas x (a#xs)" using C1 by simp
next
assume C2:"¬(x=a)"
then have "borra x (borraTodas x (a#xs)) = a#(borra x (borraTodas x xs))" using C2 by simp
also have "...=a#borraTodas x xs" using HI by simp
finally show "borra x (borraTodas x (a#xs)) = borraTodas x (a#xs)" using C2 by simp
qed
qed

-- "jaisalmen zoiruicha -- no hace falta fijar a y xs en dos líneas"
lemma borra_borraTodas:
"borra x (borraTodas x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a xs
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borra x (borraTodas x (a#xs)) = borra x (borraTodas x xs)" by simp
also have "... = borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borra x (borraTodas x (a#xs)) = borra x (a # borraTodas x xs)" by simp
also have "... = a # borra x (borraTodas x xs)" using C2 by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
borraTodas x (borraTodas x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv irealetei diecabmen1 juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 9.2. Demostrar o refutar detalladamente
borraTodas x (borraTodas x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4"

lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borraTodas x (borraTodas x (a#xs)) = borraTodas x (borraTodas x xs)" by simp
also have "... = borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borraTodas x (borraTodas x (a#xs)) = a # borraTodas x (borraTodas x xs)" by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

-- "irealetei pabflomar"
lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show "borraTodas x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI:"borraTodas x (borraTodas x xs) = borraTodas x xs"
show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a # xs)"
proof (cases)
assume A1:"x=a"
then have "borraTodas x (borraTodas x (a # xs)) = borraTodas x (borraTodas x xs)" by simp
also have "...=borraTodas x xs" using HI by simp
finally show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using A1 by simp
next
assume A2:"x≠a"
then have "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a#(borraTodas x xs))" by simp
also have "...=a # borraTodas x (borraTodas x xs)" using A2 by simp
also have "...=a # borraTodas x xs" using HI by simp
finally show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a#xs)" using A2 by simp
qed
qed

--"diecabmen1 domlloriv marescpla"
lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a xs
assume HI: "?P x xs"
show "?P x (a # xs)"
proof cases
assume C1: "x=a"
then have "borraTodas x (borraTodas x (a # xs)) = borraTodas x (borraTodas x xs)" by simp
also have "… = borraTodas x xs" using HI by simp
finally show "?P x (a # xs)" using C1 by simp
next
assume C2: "x≠a"
then have "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a # borraTodas x xs)" by simp
also have "… = a # borraTodas x (borraTodas x xs)" using C2 by simp
also have "… = a # borraTodas x xs" using HI by simp
finally show "?P x (a # xs)" using C2 by simp
qed
qed

--"juaruipav"

lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs"
proof(induct xs)
show " borraTodas x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI:"borraTodas x (borraTodas x xs) = borraTodas x xs"
show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a # xs)"
proof(cases)
assume C1: "x=a"
show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a # xs)" using HI using C1 by simp
next
assume C2: "x≠a"
show "borraTodas x (borraTodas x (a # xs)) = borraTodas x (a # xs)" using HI using C2 by simp
qed
qed

--"julrobrel"
lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show "borraTodas x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI: "borraTodas x (borraTodas x xs) = borraTodas x xs"
show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)"
proof (cases)
assume C1: "x=a"
then have "borraTodas x (borraTodas x (a#xs))=borraTodas x (borraTodas x xs)" by simp
also have "...=borraTodas x xs" using HI by simp
also have "...=borraTodas x (a#xs)" using C1 by simp
finally show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)" .
next
assume C2: "¬(x=a)"
then have "borraTodas x (borraTodas x (a#xs))=a#borraTodas x (borraTodas x xs)" by simp
also have "...=a#borraTodas x xs" using HI by simp
also have "...=borraTodas x (a#xs)" using C2 by simp
finally show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)" .
qed
qed

-- "jaisalmen zoiruicha -- no hace falta indicar a y xs por separado"

lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a xs
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borraTodas x (borraTodas x (a#xs)) = borraTodas x (borraTodas x xs)" by simp
also have "... = borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borraTodas x (borraTodas x (a#xs)) = a # borraTodas x (borraTodas x xs)" by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 10.1. Demostrar o refutar automáticamente
borraTodas x (borra x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv irealetei diecabmen1 juaruipav pabflomar marescpla jaisalmen zoiruicha"

lemma
"borraTodas x (borra x xs) = borraTodas x xs"
by (induct xs) auto

--"julrobrel"
lemma borraTodas_jrr:
"borraTodas x (borra x xs) = borraTodas x xs"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 10.2. Demostrar o refutar detalladamente
borraTodas x (borra x xs) = borraTodas x xs
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 no va un finally sin un also have antes"

lemma
"borraTodas x (borra x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borraTodas x (borra x (a#xs)) = borraTodas x xs" by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borraTodas x (borra x (a#xs)) = a # borraTodas x (borra x xs)" by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

-- "irealetei pabflomar marescpla"
lemma
"borraTodas x (borra x xs) = borraTodas x xs"
proof (induct xs)
show "borraTodas x (borra x []) = borraTodas x []" by simp
next
fix a xs
assume HI:"borraTodas x (borra x xs) = borraTodas x xs"
show "borraTodas x (borra x (a # xs)) = borraTodas x (a # xs)"
proof (cases)
assume A1:"x=a"
then have "borraTodas x (borra x (a # xs)) = borraTodas x xs" by simp
also have "...=borraTodas x (a # xs)" using A1 by simp
finally show "borraTodas x (borra x (a # xs)) = borraTodas x (a#xs)" by simp
next
assume A2:"x≠a"
then have "borraTodas x (borra x (a # xs)) = borraTodas x (a#(borra x xs))" by simp
also have "...=a # borraTodas x (borra x xs)" using A2 by simp
also have "...=a # borraTodas x xs" using HI by simp
finally show "borraTodas x (borra x (a # xs)) = borraTodas x (a#xs)" using A2 by simp
qed
qed

--" juaruipav domlloriv"
(*Domlloriv -> Este no me ha salido pero me apunto a la solucion de Juan que es mas simple*)
lemma borraTodas_conmut:
"borraTodas x (borra x xs) = borraTodas x xs"
proof (induct xs)
show " borraTodas x (borra x []) = borraTodas x []" by simp
next
fix a xs
assume HI: " borraTodas x (borra x xs) = borraTodas x xs"
show "borraTodas x (borra x (a # xs)) = borraTodas x (a # xs)"
proof(cases)
assume C1: "x=a"
show "borraTodas x (borra x (a#xs))=borraTodas x (a #xs)" using HI using C1 by simp
next
assume C2: "x≠a"
show "borraTodas x (borra x (a#xs))=borraTodas x (a #xs)" using HI using C2 by simp
qed
qed

--"julrobrel"
lemma
"borraTodas x (borraTodas x xs) = borraTodas x xs"
proof (induct xs)
show "borraTodas x (borraTodas x []) = borraTodas x []" by simp
next
fix a xs
assume HI: "borraTodas x (borraTodas x xs) = borraTodas x xs"
show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)"
proof (cases)
assume C1: "x=a"
then have "borraTodas x (borraTodas x (a#xs))=borraTodas x (borraTodas x xs)" by simp
also have "...=borraTodas x xs" using HI by simp
also have "...=borraTodas x (a#xs)" using C1 by simp
finally show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)" .
next
assume C2: "¬(x=a)"
then have "borraTodas x (borraTodas x (a#xs))=a#borraTodas x (borraTodas x xs)" by simp
also have "...=a#borraTodas x xs" using HI by simp
also have "...=borraTodas x (a#xs)" using C2 by simp
finally show "borraTodas x (borraTodas x (a#xs)) = borraTodas x (a#xs)" .
qed
qed

-- "jaisalmen zoiruicha -- similar a los anteriores con a y xs"
lemma
"borraTodas x (borra x xs) = borraTodas x xs" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a xs
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "borraTodas x (borra x (a#xs)) = borraTodas x xs" by simp
also have "... = borraTodas x (a#xs)" using C1 by simp
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "borraTodas x (borra x (a#xs)) = a # borraTodas x (borra x xs)" by simp
also have "... = a # borraTodas x xs" using HI by simp
also have "... = borraTodas x (a#xs)" using C2 by simp
finally show "?P x (a#xs)" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 11.1. Demostrar o automáticamente
borra x (borra y xs) = borra y (borra x xs)
---------------------------------------------------------------------
*}

-- "maresccas4 domlloriv irealetei diecabmen1 juaruipav pabflomar marescpla julrobrel jaisalmen zoiruicha"

lemma
"borra x (borra y xs) = borra y (borra x xs)"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 11.2. Demostrar o refutar detalladamente
borra x (borra y xs) = borra y (borra x xs)
---------------------------------------------------------------------
*}

-- "maresccas4"

lemma
"borra x (borra y xs) = borra y (borra x xs)" (is "?P x y xs")
proof (induct xs)
show "?P x y []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x y xs"
show "?P x y (a#xs)"
proof cases
assume C1: "x=a ∧ y=a"
then have "borra x (borra y (a#xs)) = borra x xs" by simp
also have "... = borra y xs" using C1 by simp
also have "... = borra y (borra x (a#xs))" using C1 by simp
finally show "?P x y (a#xs)" by simp
next
assume C2: "¬(x=a ∧ y=a)"
show "?P x y (a#xs)"
proof cases
assume C3: "x=a"
then have "borra x (borra y (a#xs)) = borra x (a # borra y xs)" by simp
also have "... = borra y xs" using C3 by simp
also have "... = borra y (borra x (a#xs))" using C3 by simp
finally show "?P x y (a#xs)" by simp
next
assume C4: "x≠a"
show "?P x y (a#xs)"
proof cases
assume C5: "y=a"
then have "borra x (borra y (a#xs)) = borra x xs" by simp
also have "... = borra y (a # borra x xs)" using C5 by simp
also have "... = borra y (borra x (a#xs))" using C5 by simp
finally show "?P x y (a#xs)" by simp
next
assume C6: "y≠a"
then have "borra x (borra y (a#xs)) = a # borra x (borra y xs)" using C4 by simp
also have "... = a # borra y (borra x xs)" using HI by simp
also have "... = borra y (a # borra x xs)" using C6 by simp
also have "... = borra y (borra x (a#xs))" using C4 by simp
finally show "?P x y (a#xs)" by simp
qed
qed
qed
qed

-- "irealetei diecabmen1 domlloriv pabflomar"
lemma
"borra x (borra y xs) = borra y (borra x xs)"
proof (induct xs)
show "borra x (borra y []) = borra y (borra x [])" by simp
next
fix a xs
assume HI: "borra x (borra y xs) = borra y (borra x xs)"
show "borra x (borra y (a # xs)) = borra y (borra x (a # xs))"
proof (cases)
assume A1:"x=a"
then have "borra x (borra y (a # xs)) = borra x (a#borra y xs)" by simp
also have "... = borra y xs" using A1 by simp
also have "...=borra y ( borra x (a # xs))" using A1 by simp
finally show "borra x (borra y (a # xs)) = borra y ( borra x (a # xs))" by simp
next
assume A2:"x≠a"
show "borra x (borra y (a # xs)) = borra y (borra x (a # xs))"
proof (cases)
assume A3:"y=a"
then have "borra x (borra y (a # xs)) = borra x xs" by simp
also have "...=borra y (a # borra x xs)" using A3 by simp
finally show "borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using A2 by simp
next
assume A4:"y≠a"
then have "borra x (borra y (a # xs)) =borra x (a#borra y xs)" by simp
also have "...=(a#(borra x (borra y xs)))" using A2 by simp
also have "...=(a#(borra y (borra x xs)))" using HI by simp
also have "...= borra y (a # borra x xs)" using A4 by simp
finally show "borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using A2 by simp
qed
qed
qed

--"juaruipav"
lemma
"borra x (borra y xs) = borra y (borra x xs)"
proof (induct xs)
show " borra x (borra y []) = borra y (borra x [])" by simp
next
fix a xs
assume HI:" borra x (borra y xs) = borra y (borra x xs)"
show " borra x (borra y (a # xs)) = borra y (borra x (a # xs))"
proof (cases)
assume C1: "x=a"
show " borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using HI using C1 by simp
next
assume C2: "x≠a"
show " borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using HI using C2 by simp
qed
qed

--"marescpla: Bueno, ya he visto que no es el más corto, pero es como lo hice"

lemma
"borra x (borra y xs) = borra y (borra x xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
show "?P (a#xs)"
proof (cases)
assume I: "x=a"
show "?P (a#xs)"
proof (cases)
assume II: "y=a"
then have "borra x (borra y (a#xs))= borra x xs" by simp
also have "...=borra y xs" using I II by simp
finally show "?P (a#xs)" using I by simp
next
assume III: "y≠a"
then have "borra x (borra y (a#xs))= borra x (a# borra y xs)" by simp
also have "...=borra y xs" using I by simp
finally show "?P (a#xs)"using I by simp
qed
next
assume III: "x≠a"
show "?P (a#xs)"
proof (cases)
assume IV: "y=a"
then have "borra x (borra y (a#xs))=borra x xs" by simp
also have "...=borra y (a#borra x xs)" using IV by simp
finally show "?P (a#xs)" using III by simp
next
assume V: "y≠a"
then have "borra x (borra y (a#xs))= borra x (a# borra y xs)" by simp
also have "...=a#borra x (borra y xs)"using III by simp
also have "...=a#borra y (borra x xs)"using HI by simp
finally show "?P (a#xs)"using V III by simp
next
qed
qed
qed

--"julrobrel"
lemma
"borra x (borra y xs) = borra y (borra x xs)"
proof (cases)
assume C1: "x=y"
show "borra x (borra y xs) = borra y (borra x xs)" using C1 by simp
next
assume C2: "¬(x=y)"
show "borra x (borra y xs) = borra y (borra x xs)"
proof (induct xs)
show "borra x (borra y []) = borra y (borra x [])" by simp
next
fix a xs
show "borra x (borra y xs) = borra y (borra x xs) ⟹ borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using C2 by simp
qed
qed

-- "jaisalmen zoiruicha"
lemma
"borra x (borra y xs) = borra y (borra x xs)" (is "?P x y xs")
proof (induct xs)
show "?P x y []" by simp
next
fix a xs
assume HI:"?P x y xs"
show "?P x y (a#xs)"
proof (cases)
assume C1: "x=a"
show " borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using HI using C1 by simp
next
assume C2: "x≠a"
show " borra x (borra y (a # xs)) = borra y (borra x (a # xs))" using HI using C2 by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 12.1. Demostrar o refutar automáticamente
borraTodas x (borra y xs) = borra y (borraTodas x xs)
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 domlloriv marescpla jaisalmen zoiruicha"

lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
by (induct xs)(auto simp add:borra_borraTodas)

-- "irealetei pabflomar"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
by (induct xs) (auto simp add:borrax_BorraTodasx_xs)

--"juaruipav"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
by (induct xs) (auto simp add: borradora)

--"julrobrel"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
by (induct xs) (auto simp add:borraTodas_jrr)

text {*
---------------------------------------------------------------------
Ejercicio 12.2. Demostrar o refutar detalladamente
borraTodas x (borra y xs) = borra y (borraTodas x xs)
---------------------------------------------------------------------
*}

-- "maresccas4"

lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)" (is "?P x y xs")
proof (induct xs)
show "?P x y []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x y xs"
show "?P x y (a#xs)"
proof cases
assume C1: "x=a ∧ y=a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x xs" by simp
also have "... = borra y (borraTodas x (a#xs))" using C1 by (simp add:borra_borraTodas)
finally show "?P x y (a#xs)" by simp
next
assume C2: "¬(x=a ∧ y=a)"
show "?P x y (a#xs)"
proof cases
assume C3: "x=a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x (a # borra y xs)" using C2 by simp
also have "... = borraTodas x (borra y xs)" using C3 by simp
also have "... = borra y (borraTodas x xs)" using HI by simp
also have "... = borra y (borraTodas x (a#xs))" using C3 by simp
finally show "?P x y (a#xs)" by simp
next
assume C4: "x≠a"
show "?P x y (a#xs)"
proof cases
assume C5: "y=a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x xs" by simp
also have "... = borra y (a # borraTodas x xs)" using C5 by simp
also have "... = borra y (borraTodas x (a#xs))" using C4 by simp
finally show "?P x y (a#xs)" by simp
next
assume C6: "y≠a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x (a # borra y xs)" by simp
also have "... = a # borraTodas x (borra y xs)" using C4 by simp
also have "... = a # borra y (borraTodas x xs)" using HI by simp
finally show "?P x y (a#xs)" using C6 C4 by simp
qed
qed
qed
qed

-- "irealetei"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
proof (induct xs)
show " borraTodas x (borra y []) = borra y (borraTodas x [])" by simp
next
fix a xs
assume HI:"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))"
proof (cases)
assume A1:"y=a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))"
proof (cases)
assume A3:"x=a"
then have "borraTodas x (borra y (a # xs))=borraTodas x xs" using A1 by simp
also have "...=borra y (a#borraTodas x xs)" using A1 by simp
also have "...=borra y (borraTodas x (a # xs))" using A3 using A1 by (simp add:borrax_BorraTodasx_xs)
finally show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" by simp
next
assume A2:"x≠a"
then have "borraTodas x (borra y (a # xs))=borraTodas x xs" using A1 by simp
also have "...=borra y (a#borraTodas x xs)" using A1 by simp
finally show "borraTodas x (borra y (a # xs))=borra y (borraTodas x (a#xs))" using A2 by simp
qed
next
assume A4:"y≠a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))"
proof (cases)
assume A5:"x=a"
then have "borraTodas x (borra y (a # xs))=borraTodas x (a#borra y xs)"using A4 by simp
also have "...=borraTodas x (borra y xs)" using A5 by simp
also have "...=borra y (borraTodas x xs)" using HI by simp
also have "...=borra y (borraTodas x (a#xs))" using A5 by simp
finally show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" by simp
next
assume A5:"x≠a"
then have "borraTodas x (borra y (a # xs))=borraTodas x (a#borra y xs)"using A4 by simp
also have "...=a#borraTodas x (borra y xs)" using A5 by simp
also have "...=a#borra y (borraTodas x xs)" using HI by simp
also have "...=borra y (a#borraTodas x (xs))" using A4 by simp
finally show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" using A5 by simp
qed
qed
qed

--"juaruipav"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
proof (induct xs)
show " borraTodas x (borra y []) = borra y (borraTodas x [])" by simp
next
fix a xs
assume HI: " borraTodas x (borra y xs) = borra y (borraTodas x xs)"
show " borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))"
proof (cases)
assume C1: "x=a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" using HI using C1 by( simp add:borradora)
next
assume C2: "x≠a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" using HI using C2 by( simp add:borradora)
qed
qed

--"diecabmen1"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)" (is "?P x y xs")
proof (induct xs)
show "?P x y []" by simp
next
fix a xs
assume HI: "?P x y xs"
show "?P x y (a # xs)"
proof cases
assume C1: "y = a"
show "?P x y (a # xs)"
proof cases
assume C2: "x = a"
then have "borraTodas x (borra y (a # xs)) = borra y (a # borraTodas x xs)" using C1 by simp
also have "… = borra y (a # borraTodas x (a # xs))" using C2 by simp
also have "… = borra y (a # borra y (borraTodas x (a # xs)))"using C2 using C1 by (simp add: borra_borraTodas)
finally show "?P x y (a # xs)" using C1 by simp
next
assume C3: "x ≠ a"
then have "borraTodas x (borra y (a # xs)) = borraTodas x xs" using C1 by simp
also have "… = borra y (a # borraTodas x xs)" using C1 by simp
finally show "?P x y (a # xs)" using C3 by simp
qed
next
assume C4: "y ≠ a"
show "?P x y (a # xs)"
proof cases
assume C5: "x = a"
then have "borraTodas x (borra y (a # xs)) = borraTodas x (a # borra y xs)" using C4 by simp
also have "… = borraTodas x (borra y xs)" using C5 by simp
also have "… = borra y (borraTodas x xs)" using HI by simp
finally show "?P x y (a # xs)" using C5 by simp
next
assume C6: "x ≠ a"
then have "borraTodas x (borra y (a # xs)) = borraTodas x (a # borra y xs)" using C4 by simp
also have "… = a # borraTodas x (borra y xs)" using C6 by simp
also have "… = a # borra y (borraTodas x xs)" using HI by simp
also have "… = borra y (a # borraTodas x xs)" using C4 by simp
finally show "?P x y (a # xs)" using C6 by simp
qed
qed
qed

--"julrobrel"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)"
proof (induct xs)
show "borraTodas x (borra y []) = borra y (borraTodas x [])" by simp
next
fix a xs
assume HI: "borraTodas x (borra y xs) = borra y (borraTodas x xs)"
show "borraTodas x (borra y (a#xs)) = borra y (borraTodas x (a#xs))"
proof (cases)
assume C1: "x=a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x (borra y xs)" using C1 by (simp add:borraTodas_jrr)
also have "...=borra y (borraTodas x xs)" using HI by simp
finally show "borraTodas x (borra y (a#xs)) = borra y (borraTodas x (a#xs))" using C1 by simp
next
assume C2: "¬(x=a)"
show "borraTodas x (borra y (a#xs)) = borra y (borraTodas x (a#xs))"
proof (cases)
assume C3: "y=a"
then have "borraTodas x (borra y (a#xs)) = borraTodas x xs" using C3 by simp
also have "...=borra y (a#borraTodas x xs)" using C3 by simp
also have "...=borra y (borraTodas x (a#xs))" using C2 by simp
finally show "borraTodas x (borra y (a#xs)) = borra y (borraTodas x (a#xs))" by simp
next
assume C4: "¬(y=a)"
then have "borraTodas x (borra y (a#xs)) = borraTodas x (a#(borra y xs))" by simp
also have "...=a#borraTodas x (borra y xs)" using C2 by simp
also have "...=a#(borra y (borraTodas x xs))" using HI by simp
also have "...=borra y (a#borraTodas x xs)" using C4 by simp
also have "...=borra y (borraTodas x (a#xs))" using C2 by simp
finally show "borraTodas x (borra y (a#xs)) = borra y (borraTodas x (a#xs))" .
qed
qed
qed

-- "jaisalmen zoiruicha"
lemma
"borraTodas x (borra y xs) = borra y (borraTodas x xs)" (is "?P x y xs")
proof (induct xs)
show "?P x y []" by simp
next
fix a xs
assume HI: "?P x y xs"
show "?P x y (a#xs)"
proof (cases)
assume C1: "x=a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" using HI using C1 by( simp add:borra_borraTodas)
next
assume C2: "x≠a"
show "borraTodas x (borra y (a # xs)) = borra y (borraTodas x (a # xs))" using HI using C2 by( simp add:borra_borraTodas)
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Demostrar o refutar:
borra y (sust x y xs) = borra x xs
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei juaruipav domlloriv diecabmen1 marescpla julrobrel zoiruicha jaisalmen"

lemma
"borra y (sust x y xs) = borra x xs"
quickcheck
oops
(* Contraejemplo
y = a⇣1
x = a⇣2
xs = [a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar o refutar:
borraTodas y (sust x y xs) = borraTodas x xs"
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei juaruipav domlloriv diecabmen1 marescpla julrobrel jaisalmen zoiruicha"

lemma
"borraTodas y (sust x y xs) = borraTodas x xs"
quickcheck
oops
(* Contraejemplo
y = a⇣1
x = a⇣2
xs = [a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 15.1. Demostrar o refutar automáticamente
sust x y (borraTodas x zs) = borraTodas x zs
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei domlloriv diecabmen1 marescpla julrobrel jaisalmen zoiruicha"
(*Domlloriv - A mi el quickcheck no me ha encontrado ningún contra ejemplo*)
(*jaisalmen - quickcheck no encuentra nada*)

lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
by (induct zs) auto

-- "juaruipav"
lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
quickcheck
oops
(*Quickcheck found a counterexample:

x = a⇩2
y = a⇩1
zs = [a⇩1]

Evaluated terms:
sust x y (borraTodas x zs) = [a⇩2]
borraTodas x zs = [a⇩1]*)

text {*
---------------------------------------------------------------------
Ejercicio 15.2. Demostrar o refutar detalladamente
sust x y (borraTodas x zs) = borraTodas x zs
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 domlloriv marescpla"

lemma sust_borraTodas:
"sust x y (borraTodas x zs) = borraTodas x zs" (is "?P x y zs")
proof (induct zs)
show "?P x y []" by simp
next
fix a :: "'a"
fix zs :: "'a list"
assume HI: "?P x y zs"
show "?P x y (a#zs)"
proof cases
assume C1: "x=a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (borraTodas x zs)" by simp
also have "... = borraTodas x zs" using HI by simp
finally show "?P x y (a#zs)" using C1 by simp
next
assume C2: "x≠a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (a # borraTodas x zs)" by simp
also have "... = a # sust x y (borraTodas x zs)" using C2 by simp
also have "... = a # borraTodas x zs" using HI by simp
finally show "?P x y (a#zs)" using C2 by simp
qed
qed

--"irealetei"
lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
proof (induct zs)
show "sust x y (borraTodas x []) = borraTodas x []" by simp
next
fix a zs
assume HI:"sust x y (borraTodas x zs) = borraTodas x zs"
show "sust x y (borraTodas x (a # zs)) = borraTodas x (a # zs)"
proof (cases)
assume A:"x=a"
then have "sust x y (borraTodas x (a # zs))=sust x y (borraTodas x zs)" by simp
also have "...=borraTodas x zs" using HI by simp
finally show "sust x y (borraTodas x (a # zs))= borraTodas x (a # zs)" using A by simp
next
assume A:"x≠a"
then have "sust x y (borraTodas x (a # zs))=sust x y (a#(borraTodas x zs))" by simp
also have "...=a#(sust x y (borraTodas x zs))" using A by simp
also have "...=a#(borraTodas x zs)" using HI by simp
finally show "sust x y (borraTodas x (a # zs))= borraTodas x (a # zs)" using A by simp
qed
qed

--"juaruipav"
lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
proof (induct zs)
show " sust x y (borraTodas x []) = borraTodas x []" by simp
next
fix a zs
assume HI: "sust x y (borraTodas x zs) = borraTodas x zs"
show " sust x y (borraTodas x (a # zs)) = borraTodas x (a # zs)"
proof(cases)
assume C1: "x=a"
show " sust x y (borraTodas x (a # zs)) = borraTodas x (a # zs)" using HI using C1 by simp
next
assume C2: "x≠a"
show " sust x y (borraTodas x (a # zs)) = borraTodas x (a # zs)" using HI using C2 by simp
qed
qed
(* Juaruipav: Falla con el siguiente mensaje: 1. sust x y (borraTodas x zs) = borraTodas x zs ⟹ x ≠ a ⟹ False
Relacionado con la salida del quickcheck*)

--"julrobrel"
lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
proof (induct zs)
show "sust x y (borraTodas x []) = borraTodas x []" by simp
next
fix a zs
assume HI:"sust x y (borraTodas x zs) = borraTodas x zs"
show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)"
proof (cases)
assume C1: "x=a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (borraTodas x zs)" using C1 by simp
also have "...=borraTodas x zs" using HI by simp
also have "...=borraTodas x (a#zs)" using C1 by simp
finally show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)" .
next
assume C2: "¬(x=a)"
then have "sust x y (borraTodas x (a#zs)) = sust x y (a#borraTodas x zs)" using C2 by simp
also have "...=a # sust x y (borraTodas x zs)" using C2 by simp
also have "...=a # borraTodas x zs" using HI by simp
also have "...=borraTodas x (a#zs)" using C2 by simp
finally show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)" .
qed
qed

-- "jaisalmen zoiruicha"
lemma sust_borraTodas:
"sust x y (borraTodas x zs) = borraTodas x zs" (is "?P x y zs")
proof (induct zs)
show "?P x y []" by simp
next
fix a zs
assume HI: "?P x y zs"
show "?P x y (a#zs)"
proof cases
assume C1: "x=a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (borraTodas x zs)" by simp
also have "... = borraTodas x zs" using HI by simp
finally show "?P x y (a#zs)" using C1 by simp
next
assume C2: "x≠a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (a # borraTodas x zs)" by simp
also have "... = a # sust x y (borraTodas x zs)" using C2 by simp
also have "... = a # borraTodas x zs" using HI by simp
finally show "?P x y (a#zs)" using C2 by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar o refutar:
sust x y (borraTodas z zs) = borraTodas z (sust x y zs)
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei juaruipav domlloriv diecabmen1 marescpla julrobrel jaisalmen zoiruicha"

lemma
"sust x y (borraTodas z zs) = borraTodas z (sust x y zs)"
quickcheck
oops
(* Contraejemplo
x = a⇣1
y = a⇣2
z = a⇣1
zs = [a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar o refutar:
rev (borra x xs) = borra x (rev xs)
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei juaruipav domlloriv diecabmen1 marescpla julrobrel jaisalmen zoiruicha"

lemma
"rev (borra x xs) = borra x (rev xs)"
quickcheck
oops
(* Contraejemplo
x = a⇣1
xs = [a⇣1, a⇣2, a⇣1]
*)

text {*
---------------------------------------------------------------------
Ejercicio 18.1. Demostrar o refutar automáticamente
borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei domlloriv diecabmen1 marescpla jaisalmen zoiruicha"

lemma
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
by (induct xs) auto

--"julrobrel"
lemma borraTodas_cat_jrr:
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
by (induct xs) auto

-- "juaripav"
lemma borraTodas_conj:
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
by (induct xs) (auto)
text {*
---------------------------------------------------------------------
Ejercicio 18.2. Demostrar o refutar detalladamente
borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1"

lemma borraTodas_concat:
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)" (is "?P x xs ys")
proof (induct xs)
show "?P x [] ys" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x xs ys"
show "?P x (a#xs) ys"
proof cases
assume C1: "x=a"
then have "borraTodas x ((a#xs)@ys) = borraTodas x (xs@ys)" by simp
also have "... = (borraTodas x xs)@(borraTodas x ys)" using HI by simp
finally show "?P x (a#xs) ys" using C1 by simp
next
assume C2: "x≠a"
then have "borraTodas x ((a#xs)@ys) = a # borraTodas x (xs@ys)" by simp
also have "... = a # (borraTodas x xs)@(borraTodas x ys)" using HI by simp
finally show "?P x (a#xs) ys" using C2 by simp
qed
qed

--"irealetei"
lemma "borraTodas_concatenacion":
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
proof (induct xs)
show "borraTodas x ([] @ ys) = borraTodas x [] @ borraTodas x ys" by simp
next
fix a xs
assume HI:"borraTodas x (xs @ ys) = borraTodas x xs @ borraTodas x ys"
show " borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys"
proof (cases)
assume A:"(x=a)"
then have "borraTodas x ((a # xs) @ ys)=borraTodas x (xs@ys)" by simp
also have "...=borraTodas x xs @ borraTodas x ys" using HI by simp
finally show " borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys" using A by simp
next
assume A:"(x≠a)"
then have "borraTodas x ((a # xs) @ ys)=a # borraTodas x (xs@ys)" by simp
also have "...=a # (borraTodas x xs @ borraTodas x ys)" using HI by simp
finally show " borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys" using A by simp
qed
qed

-- "juaruipav"
lemma
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
proof (induct xs)
show " borraTodas x ([] @ ys) = borraTodas x [] @ borraTodas x ys" by simp
next
fix a xs
assume HI: " borraTodas x (xs @ ys) = borraTodas x xs @ borraTodas x ys "
show "borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys"
proof(cases)
assume C1: "x=a"
show "borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys" using HI using C1 by simp
next
assume C2: "x≠a"
show "borraTodas x ((a # xs) @ ys) = borraTodas x (a # xs) @ borraTodas x ys" using HI using C2 by simp
qed
qed

(* Es curioso como Isabelle me avisa como poder resolverlo con un lema anterior:

Auto solve_direct: The current goal can be solved directly with
R6.borraTodas_conj:
borraTodas ?x (?xs @ ?ys) =
borraTodas ?x ?xs @ borraTodas ?x ?ys *)

--"julrobrel"
lemma
"sust x y (borraTodas x zs) = borraTodas x zs"
proof (induct zs)
show "sust x y (borraTodas x []) = borraTodas x []" by simp
next
fix a zs
assume HI:"sust x y (borraTodas x zs) = borraTodas x zs"
show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)"
proof (cases)
assume C1: "x=a"
then have "sust x y (borraTodas x (a#zs)) = sust x y (borraTodas x zs)" using C1 by simp
also have "...=borraTodas x zs" using HI by simp
also have "...=borraTodas x (a#zs)" using C1 by simp
finally show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)" .
next
assume C2: "¬(x=a)"
then have "sust x y (borraTodas x (a#zs)) = sust x y (a#borraTodas x zs)" using C2 by simp
also have "...=a # sust x y (borraTodas x zs)" using C2 by simp
also have "...=a # borraTodas x zs" using HI by simp
also have "...=borraTodas x (a#zs)" using C2 by simp
finally show "sust x y (borraTodas x (a#zs)) = borraTodas x (a#zs)" .
qed
qed

-- "jaisalmen zoiruicha"
lemma borraTodas_concat:
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)" (is "?P x xs ys")
proof (induct xs)
show "?P x [] ys" by simp
next
fix a xs
assume HI: "?P x xs ys"
show "?P x (a#xs) ys"
proof cases
assume C1: "x=a"
then have "borraTodas x ((a#xs)@ys) = borraTodas x (xs@ys)" by simp
also have "... = (borraTodas x xs)@(borraTodas x ys)" using HI by simp
finally show "?P x (a#xs) ys" using C1 by simp
next
assume C2: "x≠a"
then have "borraTodas x ((a#xs)@ys) = a # borraTodas x (xs@ys)" by simp
also have "... = a # (borraTodas x xs)@(borraTodas x ys)" using HI by simp
finally show "?P x (a#xs) ys" using C2 by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 19.1. Demostrar o refutar automáticamente
rev (borraTodas x xs) = borraTodas x (rev xs)
---------------------------------------------------------------------
*}

-- "maresccas4 diecabmen1 marescpla jaisalmen zoiruicha"

lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
by (induct xs) (auto simp add: borraTodas_concat)

-- "irealetei"

lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
by (induct xs) (auto simp add: borraTodas_concatenacion)

-- "juaruipav domlloriv"

lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
by (induct xs) (auto simp add:borraTodas_conj)

-- "julrobrel"
lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
by (induct xs) (auto simp add:borraTodas_cat_jrr)

text {*
---------------------------------------------------------------------
Ejercicio 19.2. Demostrar o refutar detalladamente
rev (borraTodas x xs) = borraTodas x (rev xs)
---------------------------------------------------------------------
*}

-- "maresccas4"

lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a :: "'a"
fix xs :: "'a list"
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "rev (borraTodas x (a#xs)) = rev (borraTodas x xs)" by simp
also have "... = borraTodas x (rev xs)" using HI by simp
also have "... = borraTodas x (rev xs) @ borraTodas x (rev [a])" using C1 by simp
also have "... = borraTodas x (rev (a#xs))" by (simp add: borraTodas_concat)
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "rev (borraTodas x (a#xs)) = rev (a # borraTodas x xs)" by simp
also have "... = rev (borraTodas x xs) @ [a]" by simp
also have "... = borraTodas x (rev xs) @ borraTodas x [a]" using HI C2 by simp
also have "... = borraTodas x (rev xs @ [a])" by (simp add: borraTodas_concat)
finally show "?P x (a#xs)" by simp
qed
qed

--"irealetei domlloriv"
lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
proof (induct xs)
show "rev (borraTodas x []) = borraTodas x (rev [])" by simp
next
fix a xs
assume HI:" rev (borraTodas x xs) = borraTodas x (rev xs)"
show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))"
proof (cases)
assume A:"x=a"
then have "rev (borraTodas x (a # xs)) = rev (borraTodas x xs)" by simp
also have "...=borraTodas x (rev xs)" using HI by simp
also have "...=borraTodas x (a#(rev xs))" using A by simp
finally show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))"using A by (simp add:borraTodas_concatenacion)
next
assume A:"x≠a"
then have "rev (borraTodas x (a # xs)) = rev (a # borraTodas x xs)" by simp
also have "...=(rev (borraTodas x xs) @ [a])" by simp
also have "...=((borraTodas x (rev xs))@[a])" using HI by simp
finally show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))"using A by (simp add:borraTodas_concatenacion)
qed
qed

--"juaruipav"
lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
proof(induct xs)
show "rev (borraTodas x []) = borraTodas x (rev [])" by simp
next
fix a xs
assume HI:"rev (borraTodas x xs) = borraTodas x (rev xs)"
show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))"
proof(cases)
assume C1: "x=a"
show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))" using HI using C1 by (simp add:borraTodas_conj)
next
assume C2: "x≠a"
show "rev (borraTodas x (a # xs)) = borraTodas x (rev (a # xs))" using HI using C2 by (simp add:borraTodas_conj)
qed
qed

--"julrobrel"
lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)"
proof (induct xs)
show "rev (borraTodas x []) = borraTodas x (rev [])" by simp
next
fix a xs
assume HI: "rev (borraTodas x xs) = borraTodas x (rev xs)"
then have "rev (borraTodas x (a#xs)) = rev (borraTodas x ([a]@xs))" by simp
also have "...=rev((borraTodas x [a]) @ (borraTodas x xs))" by (simp add:borraTodas_cat_jrr)
also have "...=rev(borraTodas x xs) @ rev(borraTodas x [a])" by simp
also have "...=borraTodas x (rev xs) @ borraTodas x (rev [a])" using HI by simp
also have "...=borraTodas x ((rev xs)@rev [a])" by (simp add:borraTodas_cat_jrr)
also have "...=borraTodas x ((rev xs)@[a])" by simp
also have "...=borraTodas x (rev (a#xs))" by simp
finally show "rev (borraTodas x (a#xs)) = borraTodas x (rev (a#xs))" .
qed

-- "jaisalmen zoiruicha"
lemma
"rev (borraTodas x xs) = borraTodas x (rev xs)" (is "?P x xs")
proof (induct xs)
show "?P x []" by simp
next
fix a xs
assume HI: "?P x xs"
show "?P x (a#xs)"
proof cases
assume C1: "x=a"
then have "rev (borraTodas x (a#xs)) = rev (borraTodas x xs)" by simp
also have "... = borraTodas x (rev xs)" using HI by simp
also have "... = borraTodas x (rev xs) @ borraTodas x (rev [a])" using C1 by simp
also have "... = borraTodas x (rev (a#xs))" by (simp add: borraTodas_concat)
finally show "?P x (a#xs)" by simp
next
assume C2: "x≠a"
then have "rev (borraTodas x (a#xs)) = rev (a # borraTodas x xs)" by simp
also have "... = rev (borraTodas x xs) @ [a]" by simp
also have "... = borraTodas x (rev xs) @ borraTodas x [a]" using HI C2 by simp
also have "... = borraTodas x (rev xs @ [a])" by (simp add: borraTodas_concat)
finally show "?P x (a#xs)" by simp
qed
qed

end

</source>

Relación 7

2018-07-16T15:46:15Z

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

<source lang="isabelle">
header {* R7: Recorridos de árboles *}

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

-- "diecabmen1 maresccas4 domlloriv pabflomar juaruipav jaisalmen zoiruicha"

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]"

-- "irealetei marescpla"
fun preOrden2 :: "'a arbol ⇒ 'a list" where
"preOrden2 (H a) = [a]"
|"preOrden2 (N dato a1 a2) = dato#(preOrden2 a1 @ preOrden2 a2)"

-- "pabflomar: ¿Realmente se nota el usar el # en lugar de la @?"

value "preOrden2 (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)))
= [a,d,c,f,h,g,e]
---------------------------------------------------------------------
*}

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav marescpla jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav jaisalmen zoiruicha"

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]"

--"marescpla"
fun inOrden2 :: "'a arbol ⇒ 'a list" where
"inOrden2 (H a)=[a]"|
"inOrden2 (N a x y) = inOrden2 x @ a # inOrden2 y"

value "inOrden2 (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))
---------------------------------------------------------------------
*}

-- "diecabmen1 maresccas4 domlloriv pabflomar juaruipav marescpla jaisalmen zoiruicha"

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))"

-- "irealetei: Es igual que la anterior pero los paréntesis no hacen falta"
fun espejo2 :: "'a arbol ⇒ 'a arbol" where
"espejo2 (H dato) = (H dato)"
| "espejo2 (N dato a1 a2) = N dato (espejo2 a2) (espejo2 a1)"

value "espejo2 (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)
---------------------------------------------------------------------
*}

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4 pabflomar"

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

-- "irealetei"
lemma "preOrden (espejo a) = rev (postOrden a)"
proof (induct a)
fix a::"'a"
show "preOrden (espejo (H a)) = rev (postOrden (H a))" by simp
next
fix data::"'a"
fix a1::"'a arbol"
assume HI1:" preOrden (espejo a1) = rev (postOrden a1)"
fix a2::"'a arbol"
assume HI2:" preOrden (espejo a2) = rev (postOrden a2)"
show "preOrden (espejo (N data a1 a2)) = rev (postOrden (N data a1 a2))"
proof -
have "preOrden (espejo (N data a1 a2))=preOrden (N data (espejo a2) (espejo a1))" by simp
also have "... = data # (preOrden(espejo a2) @ preOrden(espejo a1))" by simp
also have "... = data # (rev (postOrden a2) @ rev (postOrden a1))" using HI1 HI2 by simp
also have "... = data # (rev (postOrden a1 @ postOrden a2))" by simp
also have "... = rev (postOrden a1 @ postOrden a2 @ [data])" by simp
also have "... = rev (postOrden (N data a1 a2))" by simp
finally show ?thesis by simp
qed
qed

--"marescpla"
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix a:: "'a arbol"
fix x:: "'a"
show "?P (H x)" by simp
next
fix a:: "'a"
fix x:: "'a arbol"
fix y :: "'a arbol"
fix t :: "'a arbol"
assume HI : "?P x"
assume HII : "?P y"
have "preOrden (espejo (N a x y))= preOrden (N a (espejo y) (espejo x))" by (simp only: espejo.simps(2))
also have "... = a # (preOrden (espejo y) @ preOrden (espejo x))" by (simp only: preOrden2.simps(2))
also have "... = a # (rev (postOrden y) @ rev (postOrden x))" using HI HII by simp
also have "... = rev (postOrden x @ postOrden y @ [a])" by simp
finally show "preOrden (espejo (N a x y))= rev (postOrden (N a x y))" by simp
qed

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4"

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

--"irealetei"
lemma "postOrden (espejo a) = rev (preOrden a)"
proof (induct a)
fix a::"'a"
show "postOrden (espejo (H a)) = rev (preOrden (H a))" by simp
next
fix data::"'a"
fix a1::"'a arbol"
assume HI1:" postOrden (espejo a1) = rev (preOrden a1)"
fix a2::"'a arbol"
assume HI2:" postOrden (espejo a2) = rev (preOrden a2)"
show "postOrden (espejo (N data a1 a2)) = rev (preOrden (N data a1 a2))"
proof -
have "postOrden (espejo (N data a1 a2))=postOrden (N data (espejo a2) (espejo a1))" by simp
also have "... = postOrden(espejo a2) @ postOrden(espejo a1) @ [data]" by simp
also have "... = rev (preOrden a2) @ rev (preOrden a1) @ [data]" using HI1 HI2 by simp
also have "... = rev (preOrden a1 @ preOrden a2)@[data]" by simp
also have "... = rev (preOrden a1 @ preOrden a2)@ rev ([data])" by simp
also have "... = rev ([data] @ preOrden a1 @ preOrden a2)" by simp
also have "... = rev (preOrden (N data a1 a2))" by simp
finally show ?thesis by simp
qed
qed

--"marescpla"
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix a:: "'a arbol"
fix x:: "'a"
show "?P (H x)" by simp
next
fix a:: "'a"
fix x:: "'a arbol"
fix y :: "'a arbol"
fix t :: "'a arbol"
assume HI : "?P x"
assume HII : "?P y"
have "postOrden (espejo (N a x y))= postOrden (N a (espejo y) (espejo x))" by (simp only: espejo.simps(2))
also have "... = (postOrden (espejo y) @ postOrden (espejo x)) @ [a]" by (simp only: postOrden.simps(2))
also have "... = (rev (preOrden y) @ rev (preOrden x)) @ [a]" using HI HII by simp
also have "... = rev (a # preOrden x @ preOrden y)" by simp
finally show "postOrden (espejo (N a x y))= rev (preOrden (N a x y))" by simp
qed

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav jaisalmen zoiruicha"

theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

-- "diecabmen1 maresccas4"

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

-- "irealetei"
lemma "inOrden (espejo a) = rev (inOrden a)"
proof (induct a)
fix a::"'a"
show "inOrden (espejo (H a)) = rev (inOrden (H a))" by simp
next
fix data::"'a"
fix a1::"'a arbol"
assume HI1:" inOrden (espejo a1) = rev (inOrden a1)"
fix a2::"'a arbol"
assume HI2:" inOrden (espejo a2) = rev (inOrden a2)"
show "inOrden (espejo (N data a1 a2)) = rev (inOrden (N data a1 a2))"
proof -
have "inOrden (espejo (N data a1 a2))=inOrden (N data (espejo a2) (espejo a1))" by simp
also have "... = inOrden(espejo a2) @ [data] @ inOrden(espejo a1)" by simp
also have "... = rev (inOrden a2)@ [data] @ rev (inOrden a1)" using HI1 HI2 by simp
also have "... = rev (inOrden a2)@ rev([data]) @ rev (inOrden a1)" by simp
also have "... = rev ([data] @ (inOrden a2)) @ rev(inOrden a1)" by simp
also have "... = rev ( inOrden a1 @ [data] @ inOrden a2)" by simp
also have "... = rev (inOrden (N data a1 a2))" by simp
finally show ?thesis by simp
qed
qed

--"marescpla"
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix a:: "'a arbol"
fix x:: "'a"
show "?P (H x)" by simp
next
fix a:: "'a"
fix x:: "'a arbol"
fix y :: "'a arbol"
fix t :: "'a arbol"
assume HI : "?P x"
assume HII : "?P y"
have "inOrden (espejo (N a x y))= inOrden (N a (espejo y) (espejo x))" by (simp only: espejo.simps(2))
also have "... = (inOrden (espejo y) @ a # inOrden (espejo x))" by (simp only: inOrden.simps(2))
also have "... = (rev (inOrden y) @ a # rev (inOrden x))" using HI HII by simp
also have "... = rev (inOrden x @ a # inOrden y)" by simp
finally show "inOrden (espejo (N a x y))= rev (inOrden (N a x y))" by simp
qed

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav marescpla jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav marescpla jaisalmen zoiruicha"

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

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

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

-- "diecabmen1 maresccas4 irealetei domlloriv pabflomar juaruipav marescpla jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4 domlloriv juaruipav"

lemma inOrdenNN: "inOrden a ≠ []"
by (induct a) auto

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)
also have "… = extremo_derecha a3" using HI2 by simp
finally show ?thesis by simp
qed
qed

--"irealetei jaisalmen zoiruicha"
lemma inOrdenNoPuedeSerVacio: "inOrden a ≠ []"
by (induct a) auto

theorem "last (inOrden a) = extremo_derecha a"
by (induct a) (auto simp add:inOrdenNoPuedeSerVacio)

theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix data::"'a"
show "last (inOrden (H data)) = extremo_derecha (H data)" by simp
next
fix data::"'a"
fix a2::"'a arbol"
fix a1
assume HI:" last (inOrden a2) = extremo_derecha a2"
show "last (inOrden (N data a1 a2)) = extremo_derecha (N data a1 a2)"
proof -
have "last (inOrden (N data a1 a2))= last ((inOrden a1)@[data] @ (inOrden a2))" by simp
also have "...= last (inOrden a2)" by (simp add:inOrdenNoPuedeSerVacio)
also have "...=extremo_derecha a2" using HI by simp
also have "...=extremo_derecha (N data a1 a2)" by simp
finally show ?thesis by simp
qed
qed

--"marescpla"

lemma inOrdenDistintoVacio:
"inOrden a ≠ []" (is "?P a")
proof (induct a)
fix a :: "'a arbol"
fix x :: "'a"
show "?P (H x)" by simp
next
fix a1:: "'a"
fix a2:: "'a arbol"
fix a3:: "'a arbol"
assume HI: "?P a2"
have "inOrden (N a1 a2 a3)= inOrden a2 @ a1 # inOrden a3" by (simp only: inOrden.simps(2))
also have "… ≠ []" using HI by simp
finally show "inOrden (N a1 a2 a3) ≠ []" by simp
qed

theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induction a)
fix x :: "'a"
show "?P (H x)" by simp
next
fix a :: "'a"
fix x :: "'a arbol"
fix y :: "'a arbol"
assume HII : "?P y"
have "last (inOrden (N a x y)) = last (inOrden x @ a # inOrden y)" by (simp only: inOrden.simps(2))
also have "... = last (a # inOrden y)" by (simp add: inOrdenDistintoVacio)
also have "... = last (inOrden y)" by (simp add: inOrdenDistintoVacio)
also have "... = extremo_derecha y" using HII by simp
finally show "last (inOrden (N a x y)) = extremo_derecha (N a x y)" by simp
qed

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

-- "diecabmen1 maresccas4 irealetei domlloriv juaruipav"

theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a) (auto simp add: inOrdenNN)

-- "diecabmen1 maresccas4 "

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)
also have "… = extremo_izquierda a2" using HI1 by simp
finally show ?thesis by simp
qed
qed

-- "irealetei"
theorem "hd (inOrden a) = extremo_izquierda a"
proof (induct a)
fix data::"'a"
show "hd (inOrden (H data)) = extremo_izquierda (H data)" by simp
next
fix data::"'a"
fix a1::"'a arbol"
fix a2
assume HI:" hd (inOrden a1) = extremo_izquierda a1"
show "hd (inOrden (N data a1 a2)) = extremo_izquierda (N data a1 a2)"
proof -
have "hd (inOrden (N data a1 a2))= hd ((inOrden a1)@[data] @ (inOrden a2))" by simp
also have "...= hd (inOrden a1)" by (simp add:inOrdenNoPuedeSerVacio)
also have "...=extremo_izquierda a1" using HI by simp
also have "...=extremo_izquierda (N data a1 a2)" by simp
finally show ?thesis by simp
qed
qed

--"marescpla"

theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix a:: "'a arbol"
fix x:: "'a"
show "?P (H x)" by simp
next
fix a :: "'a"
fix x :: "'a arbol"
fix y :: "'a arbol"
assume HI: "?P x"
have "hd (inOrden (N a x y))= hd (inOrden x @ a # inOrden y)" by (simp only: inOrden.simps(2))
also have "...=hd (inOrden x)" by ( simp add: inOrdenDistintoVacio)
also have "...= extremo_izquierda x" using HI by simp
finally show "hd (inOrden (N a x y)) = extremo_izquierda (N a x y)" by simp
qed

-- "jaisalmen zoiruicha"
theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a) (auto simp add: inOrdenNoPuedeSerVacio

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

-- "diecabmen1 maresccas4 domlloriv juaruipav jaisalmen zoiruicha"

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

-- "diecabmen1 maresccas4"

theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp
also have "… = a1" by simp
finally show ?thesis by simp
qed
qed

-- "irealetei: Se puede hacer con cases"
theorem "hd (preOrden a) = last (postOrden a)"
by (cases a) auto

theorem "hd (preOrden a) = last (postOrden a)"
proof (cases a)
fix data
assume "a = H data"
then show "hd (preOrden a) = last (postOrden a)" by simp
next
fix data::"'a"
fix a1::"'a arbol"
fix a2::"'a arbol"
assume A:"a = N data a1 a2"
then
have "hd (preOrden (N data a1 a2)) = hd (data #(preOrden a1 @ preOrden a2))" by simp
also have "... = data" by simp
also have "... = last (postOrden a1 @ postOrden a2 @ [data])" by simp
also have "... = last (postOrden (N data a1 a1))" by simp
finally show ?thesis using A by simp
qed

--"marescpla"

theorem T1: "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (cases a)
fix a:: "'a arbol"
fix x:: "'a"
assume H1 : "a = (H x)"
then have "hd (preOrden a)= hd (preOrden (H x))" by simp
also have "... = last (postOrden (H x))" by simp
finally show "?P a" using H1 by simp
next
fix t :: "'a"
fix x :: "'a arbol"
fix y :: "'a arbol"
assume H2: "a = (N t x y)"
then have "hd (preOrden a)= hd (preOrden (N t x y))" by simp
have "hd (preOrden (N t x y))= hd (t # preOrden x @ preOrden y)" by (simp only: preOrden2.simps(2))
also have "...= t " by (simp only: hd.simps(1))
finally show "hd (preOrden a)= last (postOrden a)" using H2 by simp
qed

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

-- "diecabmen1 maresccas4 domlloriv juaruipav zoiruicha jaisalmen"

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

-- "diecabmen1 maresccas4"

theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp
also have "… = a1" by simp
finally show ?thesis by simp
qed
qed

-- "irealetei"

theorem "hd (preOrden a) = raiz a"
by (cases a) auto

theorem "hd (preOrden a) = raiz a"
proof (cases a)
fix data
assume "a = H data"
then show "hd (preOrden a) = raiz a" by simp
next
fix data::"'a"
fix a1::"'a arbol"
fix a2::"'a arbol"
assume A:"a = N data a1 a2"
then
have "hd (preOrden (N data a1 a2)) = hd (data #(preOrden a1 @ preOrden a2))" by simp
also have "... = data" by simp
also have "... = raiz (N data a1 a2)" by simp
finally show ?thesis using A by simp
qed

--"marescpla"

theorem T2: "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix a ::"'a arbol"
fix x::"'a"
assume " a = (H x)"
then show "?P a" by simp
next
fix a ::"'a arbol"
fix t::"'a"
fix x ::"'a arbol"
fix y ::"'a arbol"
assume H: " a = (N t x y)"
then have "hd (preOrden a) = hd (t # preOrden x @ preOrden y)" by simp
also have "...= t" by simp
finally show "?P a" using H by simp
qed

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

-- "diecabmen1 maresccas4 irealetei domlloriv juaruipav marescpla jaisalmen zoiruicha"

theorem "hd (inOrden a) = raiz a"
quickcheck
oops
(* Quickcheck found a counterexample:

a = N a⇩1 (H a⇩2) (H a⇩1)

Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)

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

-- "diecabmen1 maresccas4 domlloriv juaruipav jaisalmen zoiruicha"

theorem "last (postOrden a) = raiz a"
by (induct a) auto

-- "diecabmen1 maresccas4"

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix a1 a2 a3
assume HI1: "?P a2"
assume HI2: "?P a3"
show "?P (N a1 a2 a3)"
proof -
thm postOrden.simps
thm hd.simps
thm raiz.simps
have " last (postOrden (N a1 a2 a3)) = last (postOrden a2 @ postOrden a3 @ [a1])" by simp
also have "… = last ([a1])" by simp
finally show ?thesis by simp
qed
qed

--"irealetei"

theorem "last (postOrden a) = raiz a"
by (cases a) auto

theorem "last (postOrden a) = raiz a"
proof (cases a)
fix data
assume "a = H data"
then show "last (postOrden a) = raiz a" by simp
next
fix data::"'a"
fix a1::"'a arbol"
fix a2::"'a arbol"
assume A:"a = N data a1 a2"
then
have "last (postOrden (N data a1 a2)) = last (preOrden a1 @ preOrden a2 @ [data])" by simp
also have "... = data" by simp
also have "... = raiz (N data a1 a2)" by simp
finally show ?thesis using A by simp
qed

--"marescpla"

theorem "last (postOrden a) = raiz a" (is "?P a")
proof-
have "last (postOrden a) = hd (preOrden a)" by (simp add:T1)
also have "... = raiz a" by (simp add: T2)
finally show "?P a" by simp
qed

end
</source>

Relación 3

2018-07-16T15:46:14Z

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

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

theory R3
imports Main
begin

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

-- "maresccas4 irealetei diecabmen1 domlloriv pabflomar marescpla"

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

value "sumaImpares 5" -- "= 25"

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

value "sumaImpares2 5" -- "= 25"

-- "jaisalmen zoiruicha"
fun sumaImpares3 :: "nat ⇒ nat" where
"sumaImpares3 0 = 0"
| "sumaImpares3 (n) = (2 * n) - 1 + sumaImpares3 (n - 1)"

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

-- "maresccas4 pabflomar juaruipav marescpla jaisalmen zoiruicha"
-- "jaisalmen: con la definición sumaImpares3 me da algunos errores al tratar de probar por inducción"

lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by simp
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = 2 * n + 1 + sumaImpares n" by (simp only: sumaImpares.simps(2))
also have "... = 2 * n + 1 + n * n" using HI by simp
finally show "sumaImpares (Suc n) = (Suc n) * (Suc n)" by simp
qed

-- "irealetei diecabmen1 domlloriv"
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares (0) = 0 * 0" by simp
next
fix n
assume HI: "sumaImpares n = n * n"
have "sumaImpares (Suc n) = (2*n + 1) + sumaImpares n " by simp
also have "... = 2*n + 1 + (n * n)" using HI by simp
also have "...= (n+1)*(n+1)" by simp
finally show "sumaImpares (Suc n) =Suc n * Suc n" by simp
qed

-- "Sobrarían varios parentesis."

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

-- "ElyIvan"

lemma "sumaImpares n = n*n"
proof -
by (induc n)
show "sumaImpares 0 = 0*0" by simp
next
assume HI: "sumaImpares n = n * n"
have "sumaImpares n = 2 * n - 1) + sumaImpares ( n- 1 )" by sumanImpares2
also have "...= 2 * n - 1 + (n - 1) * ( n - 1)" using HI by simp
also have "...= 2 * n -1 + n * n - 2 * n + 1" by simp
also have "...= n * n" by simp
finally show "sumaImpares n = n * n" by simp
qed

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

-- "maresccas4 irealetei diecabmen1 domlloriv pabflomar julrobrel"

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
| "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n) + sumaPotenciasDeDosMasUno n"

value "sumaPotenciasDeDosMasUno 3" -- "= 16"

-- "ElyIvan jaisalmen zoiruicha"

fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2"
| "sumaPotenciasDeDosMasUno2 n = 2^n + sumaPotenciasDeDosMasUno2 (n-1)"

value "sumaPotenciasDeDosMasUno2 1" -- "= 16"

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

-- "maresccas4 pabflomar juaruipav jaisalmen zoiruicha"

lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n) + sumaPotenciasDeDosMasUno n" by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2^(Suc n) + 2^(n+1)" using HI by simp
also have "... = 2^(n+1) + 2^(n+1)" by simp
also have "... = 2 * 2^(n+1)" by simp
also have "... = 2 * 2^(Suc n)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

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

--"diecabmen1, marescpla"
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n)+sumaPotenciasDeDosMasUno n" by simp
also have "… = (2^(Suc n)) + (2^(n+1))" using HI by simp
also have "… = 2^(n+1) + 2^(n+1)" by simp
also have "… = 2 * 2^(Suc n)" by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n +1)" by simp
qed

--"en el primer have yo especifiqué la regla usada: by (simp only: sumaPotenciasDeDosMasUno.simps(2)) marescpla"

--"domlloriv"
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n) + sumaPotenciasDeDosMasUno n" by simp
also have "... = 2^(Suc n) + 2^(n+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

-- "julrobrel"
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" by simp
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n) + sumaPotenciasDeDosMasUno n" by simp
also have "...= 2^((n+1)+1)" using HI by simp
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" by simp
qed

-- "ElyIvan"

lemma "sumaPotenciasDeDosMasUno2 n = 2^(n+1)"
proof (induct n)
show "sumaPotenciasDeDosMasUno2 0 = 2^(0+1)" by simp
next
fix n
assume HI "sumaPotenciasDeDosMasUno2 n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno2 n = 2^n + sumaPotenciasDeDosMasUno2 (n-1)" by sumaPotenciasDeDosMasUno2 2
also have "...= 2^n + 2 ^((n-1)+1)" by HI
also have "...= 2^n + 2^n" by simp
finally show "sumaPotenciasDeDosMasUno2 n = 2^(n+1)" by simp
qed

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

-- "maresccas4 irealetei diecabmen1 domlloriv pabflomar julrobrel marescpla jaisalmen zoiruicha"

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

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

-- "ElyIvan"

fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []"
| "copia2 n x = x # copia2 ( n - 1 ) x"

value "copia2 3 x" -- "= [x,x,x]"

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

-- "maresccas4 irealetei diecabmen1 domlloriv pabflomar julrobrel marescpla"

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

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

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

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

-- "maresccas4"

lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = todos (λy. y=x) (x # copia n x)" by (simp only: copia.simps(2))
also have "... = todos (λy. y=x) (copia n x)" by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" using HI by simp
qed

-- "irealetei diecabmen1 pabflomar jaisalmen zoiruicha"
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y = x) (copia 0 x)" by simp
next
fix n
assume HI: " todos (λy. y = x) (copia n x)"
have " todos (λy. y = x) (copia (Suc n) x)= todos (λy. y = x) (x#copia n x)" by simp
also have "... = todos (λy. y = x) (copia n x)" by simp
also have "... = True" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

-- "domlloriv"
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI:"todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" using HI by simp
also have "... = True" using HI by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

-- "julrobrel"
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y = x) (copia n x)"
have "todos (λy. y = x) (copia (Suc n) x)=todos (λy. y = x) (x # copia n x)" by simp
also have "...=(λy. y = x) x ∧ todos (λy. y = x) (copia n x)" using HI by simp
finally show "todos (λy. y = x) (copia (Suc n) x)" by simp
qed

-- "juaruipav"
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
show "todos (λy. y=x) (copia 0 x)" by simp
next
fix n
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x)= todos (λy. y=x)(x# (copia n x))" by simp
also have "...=todos (λy. y=x)[x]" using HI by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

--"marescpla"

lemma "todos (λy. y=x) (copia n x)"
proof(induct n)
show "todos (λy. y=x) (copia 0 x)" by (simp only: copia.simps(1) todos.simps(1))
next
fix n
assume HI : "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) = ((λy. y=x) (hd (copia (Suc n) x)) ∧ todos (λy. y=x) (tl(copia (Suc n) x)))" by simp
also have "...= ((λy. y=x) (hd (x # copia n x))∧ todos (λy. y=x) (tl(copia (Suc n) x)))" by (simp only: copia.simps(2))
also have " ...= ((λy. y=x) x ∧ todos (λy. y=x) (tl(copia (Suc n) x)))" by (simp only: hd.simps)
also have "...=(todos (λy. y=x) (tl(copia (Suc n) x)))" by simp
also have "...=(todos (λy. y=x) (tl(x # copia n x)))" by (simp only: copia.simps(2))
also have "...=(todos (λy. y=x) (copia n x))" by (simp only: tl.simps)
also have "...= True" using HI by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" by simp
qed

--"jajaja ya he visto que me he complicado demasiado. Es mejor resolverlo en el otro orden"

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

-- "maresccas4 irealetei diecabmen1 domlloriv pabflomar julrobrel marescpla jaisalmen zoiruicha"

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
| "factR (Suc n) = Suc n * factR n"

value "factR 4" -- "= 24"

text {* ---------------------------------------------------------------
Ejercicio 9. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (Suc n)*x"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

value "factI 4" -- "= 24"

-- "maresccas4"

lemma fact: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (Suc n)*x" by (simp only: factI'.simps(2))
also have "... = x * factI' n (Suc n)" by simp
also have "... = x * ((Suc n) * factR n)" using HI by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed
qed

-- "jaisalmen zoiruicha"
-- "jaisalmen" (*lo tengo similar sin embargo me sale un error q no entiendo*)
-- "irealetei" (*Éste ha sido la muerte a pellizcos, aún leyéndome todo el tema.*)
lemma fact2: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n x
assume HI: "⋀x. factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (Suc n)*x" by simp
also have "... = x * factI' n (Suc n)" by simp
also have "... = x * (Suc n * factR n)" using HI by simp
also have "... = x * factR (Suc n)" by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

-- "diecabmen1" (*Es el mismo que de irealetei solo que me parece que se puede eliminar el último also have y ponerlo directo en el finally.*)
lemma fact3: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n x
assume HI: "⋀x. factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (Suc n)*x" by simp
also have "… = x * ((Suc n) * factR n)" using HI by simp
finally show "factI' (Suc n) x = x * factR (Suc n)" by simp
qed

-- "domlloriv"
lemma fact4: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp (*Para todo x se cumple*)
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (Suc n)*x" using HI by simp
also have "... = x * (Suc n * factR n)" using HI by simp
finally show "⋀x. factI' (Suc n) x = x * factR (Suc n)" using HI by simp
qed

(* Comentario: "using HI" se necesita sólo una vez. *)

-- "julrobrel"
lemma fact5: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x = x * factR 0" by simp
next
fix n x
assume HI: "⋀x. factI' n x = x * factR n"
have "factI' (Suc n) x = factI' n (Suc n)*x" by simp
also have "...=x * ((Suc n) * factR n)" using HI by simp
finally show "factI' (Suc n) x = x* factR (Suc n)" by simp
qed

-- "juaruipav"

lemma fact6: "factI' n x = x * factR n"
proof (induct n arbitrary: x)
show "⋀x. factI' 0 x= x*factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
have "factI'(Suc n) x= factI' n (Suc n)*x" by simp
also have "...=x*((Suc n)*factR n)" using HI by simp
finally show "⋀x. factI' (Suc n) x = x*factR (Suc n)" by simp
qed

-- " juaruipav: No me termina de funcionar"

-- "pabflomar los entiendo casi todos pero yo no habría sacado ni uno de ellos"

--"marescpla (no me resuelve el paso de inducción"
lemma fact: "factI' n x = x * factR n"
proof (induct n)
show "factI' 0 x = x* factR 0" by (simp only: factI'.simps(1) factR.simps(1))
next
fix n
assume HI : "factI' n x = x * factR n"
have " factI' (Suc n) x= factI' n (Suc n)*x" by (simp only: factI'.simps(2))
also have "...= (Suc n)*x * factR n" using HI by simp
also have " ... = x * (Suc n)*factR n" by simp
also have " ... = x * factR (Suc n)" by (simp only: factR.simps(2))
finally show " factI' (Suc n) x = x * factR (Suc n)" by simp
qed

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

-- "maresccas4 julrobrel"

corollary "factI n = factR n"
proof -
show "factI n = factR n" by (simp add:fact)
qed

-- "irealetei diecabmen1 domlloriv pabflomar juaruipav jaisalmen zoiruicha"
corollary "factI n = factR n"
by (simp add: fact)

--"marescpla"
corollary "factI n = factR n"
proof-
have "factI n = factI' n 1" by (simp only: factI.simps(1))
also have " ...= 1*factR n" by (simp add: fact)
finally show "factI n = factR n" by simp
qed

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

-- "maresccas4 irealetei diecabmen1 domlloriv julrobrel marescpla jaisalmen zoiruicha"

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

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

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

-- "maresccas4 marescpla"

lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x # (amplia xs y)" by (simp only: amplia.simps(2))
also have "... = x # xs @ [y]" using HI by simp
finally show "amplia (x#xs) y = (x#xs) @ [y]" by simp
qed

--"irealetei diecabmen1 domlloriv pabflomar juaruipav jaisalmen zoiruicha"
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix a xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (a#xs) y = a # (amplia xs y)" by simp
also have "... = (a # xs) @ [y]" using HI by simp
finally show "amplia (a#xs) y = (a # xs) @ [y]" by simp
qed

-- "julrobrel"
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI:"amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x # (amplia xs y)" by simp
also have "...= x # (xs @ [y])" using HI by simp
finally show "amplia (x#xs) y = (x#xs) @ [y]" by simp
qed

end
</source>

Relación 4

2018-07-16T15:46:14Z

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

<source lang="isabelle">
header {* R4: Cons inverso *}

theory R4
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir recursivamente la función
snoc :: "'a list ⇒ 'a ⇒ 'a list"
tal que (snoc xs a) es la lista obtenida al añadir el elemento a al
final de la lista xs. Por ejemplo,
value "snoc [2,5] (3::int)" == [2,5,3]

Nota: No usar @.
---------------------------------------------------------------------
*}
-- "pabflomar irealetei maresccas4 domlloriv diecabmen1 jaisalmen juaruipav marescpla"
fun snoc :: "'a list ⇒ 'a ⇒ 'a list" where
"snoc [] a = [a]"
| "snoc (x#xs) a = x # (snoc xs a)"

value "snoc [2,5] (3::int)" -- "[2,5,3]"

text {*
---------------------------------------------------------------------
Ejercicio 2. Demostrar automáticamente el siguiente teorema
snoc xs a = xs @ [a]
---------------------------------------------------------------------
*}
-- "pabflomar irealetei maresccas4 domlloriv diecabmen1 jaisalmen juaruipav marescpla"
lemma "snoc xs a = xs @ [a]"
by (induct xs) auto

text {*
---------------------------------------------------------------------
Ejercicio 3. Demostrar detalladamente el siguiente teorema
snoc xs a = xs @ [a]
---------------------------------------------------------------------
*}
-- "pabflomar irealetei maresccas4 domlloriv diecabmen1 jaisalmen juaruipav marescpla"
lemma snoc_append: "snoc xs a = xs @ [a]"
proof (induct xs)
show " snoc [] a = [] @ [a]" by simp
next
fix aa xs
assume HI: "snoc xs a = xs @ [a]"
have "snoc (aa # xs) a = aa # snoc xs a" by simp
also have "... = aa # xs @ [a]" using HI by simp
finally show "snoc (aa # xs) a = (aa # xs) @ [a]" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar automáticamente el siguiente lema
rev (x # xs) = snoc (rev xs) x"
---------------------------------------------------------------------
*}

-- "pabflomar irealetei maresccas4 domlloriv jaisalmen juaruipav marescpla"
lemma "rev (x # xs) = snoc (rev xs) x"
by (simp add: snoc_append)

text {*
---------------------------------------------------------------------
Ejercicio 5. Demostrar detalladamente el siguiente lema
rev (x # xs) = snoc (rev xs) x"
---------------------------------------------------------------------
*}

(* maresccas4 - ¿Tiene sentido realizar la demostración automática por simplificación y
posteriormente hacerla detallada haciendo uso de la inducción? *)

(* pabflomar - Marco llevas razón, pero yo fui el primero en los anteriores ejercicios, PRINGAO :P, como dirían en forocoches... POLE *)
(* pabflomar - Irene, transfuga.*)
(* pabflomar - Obviamente, la solución de Marco es la correcta. Dejo esta por motivos de demostrar mi estupidez al querer ser el primero :) *)

-- "pabflomar diecabmen1"
lemma "rev (x # xs) = snoc (rev xs) x"
proof (induct xs)
show "rev [x] = snoc (rev []) x" by simp
next
fix a xs
assume HI: "rev (x # xs) = snoc (rev xs) x"
have "rev (x # a # xs) =rev (a # xs) @ rev [x]" by simp
also have "... = snoc (rev (a # xs)) x" using HI by (simp add: snoc_append)
finally show "rev (x # a # xs) = snoc (rev (a # xs)) x" by simp
qed

-- "maresccas4 irealetei domlloriv jaisalmen juaruipav marescpla" (* Marco, como siempre, tiene razón. Abandono el barco, Pablo*)(*definitivamente esto es magia callejera para mi. Marco podrías poner una breve explicación de como obtuviste la definición de rev para poner el rev.simp?, diecabmen1*)
lemma "rev (x # xs) = snoc (rev xs) x"
proof -
have "rev (x#xs) = rev xs @ [x]" by (simp only:rev.simps)
also have "... = snoc (rev xs) x" by (simp add:snoc_append)
finally show "rev (x#xs) = snoc (rev xs) x" by simp
qed

end
</source>

Relación 5

2018-07-16T15:46:14Z

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

<source lang="isabelle">
header {* R5: Cuantificadores sobre listas *}

theory R5
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir la función
todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (todos p xs) se verifica si todos los elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
todos (λx. 1<length x) [[2,1,4],[1,3]]
¬todos (λx. 1<length x) [[2,1,4],[3]]

Nota: La función todos es equivalente a la predefinida list_all.
---------------------------------------------------------------------
*}
-- "irealetei diecabmen1 pabflomar maresccas4 domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True"
|"todos p (x#xs) =(p x ∧ todos p xs)"

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

-- "diecabmen1"
value "algunos (λx. 1<length x) [[2,1,4],[3]]"
value "algunos (λx. 1<length x) [[],[3]]"

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool
tal que (algunos p xs) se verifica si algunos elementos de la lista
xs cumplen la propiedad p. Por ejemplo, se verifica
algunos (λx. 1<length x) [[2,1,4],[3]]
¬algunos (λx. 1<length x) [[],[3]]"

Nota: La función algunos es equivalente a la predefinida list_ex.
---------------------------------------------------------------------
*}

-- "irealetei diecabmen1 pabflomar maresccas4 domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False"
| "algunos p (x#xs) = (p x ∨ algunos p (xs))" --"(xs)=xs julrobrel"

value "algunos (λx. 1<length x) [[2,1,4],[3]]" -- "TRUE"
value "algunos (λx. 1<length x) [[],[3]]" -- "FALSE"

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

-- "irealetei diecabmen1 pabflomar domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

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

-- "irealetei pabflomar maresccas4 juaruipav domlloriv"
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x)[] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a#xs) = ((P a ∧ Q a) ∧ todos (λx. P x ∧ Q x) xs )" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)" using HI by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto
qed

-- "diecabmen1 jaisalmen zoiruicha"
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos (λx. P x ∧ Q x) (a # xs) = (( P a ∧ Q a) ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "… = (( P a ∧ Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp
finally show "?P (a#xs)" by auto
qed

--"marescpla"
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P Q xs")
proof (induct xs)
show "?P Q []" by simp
next
fix x xs
assume HI: "?P Q xs"
have "todos (λx. P x ∧ Q x) (x#xs) =((λx. P x ∧ Q x) x ∧ todos (λx. P x ∧ Q x) xs)" by (simp only: todos.simps(2))
also have " ... = ((λx. P x ∧ Q x) x ∧ todos P xs ∧ todos Q xs)" using HI by simp
also have " ...= ((P x) ∧ (Q x) ∧ todos P xs ∧ todos Q xs) " by simp
also have "... =((P x) ∧ todos P xs ∧ (Q x)∧ todos Q xs)" by auto
also have " ...= (todos P (x#xs) ∧ todos Q (x#xs))" by simp
finally show "?P Q (x#xs)" by simp
qed

--"julrobrel: sin usar auto"
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix a xs
assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (a#xs) = ((P a ∧ Q a) ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "...=((P a ∧ Q a) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "...=((P a) ∧ ((Q a) ∧ (todos P xs)) ∧ (todos Q xs))" by simp
also have "...=((P a) ∧ ((todos P xs) ∧ (Q a)) ∧ (todos Q xs))" by (simp add:conj_commute)
also have "...=((todos P [a]) ∧ (todos P xs) ∧ (todos Q [a]) ∧ (todos Q xs))" by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) = (todos P (a#xs) ∧ todos Q (a#xs))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

-- "irealetei diecabmen1 pabflomar maresccas4 domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x ) auto

text {*
---------------------------------------------------------------------
Ejercicio 4.2. Demostrar o refutar detalladamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}
-- "irealetei pabflomar maresccas4 domllorv juaruipav julrobrel"
lemma todos_append:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"
have " todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp
also have "...= (P a ∧ todos P x ∧ todos P y)" using HI by simp
finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp
qed

-- "diecabmen1 marescpla jaisalmen zoiruicha"
lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)" (is "?P x y")
proof (induct x)
show "?P [] y" by simp
next
fix a x
assume HI: "?P x y"
have "todos P (a#x @ y) = (P a ∧ todos P (x@y))" by simp
also have "… = (P a ∧ todos P x ∧ todos P y)" using HI by simp
finally show "?P (a#x) y" by auto
qed

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

--"maresccas4 julrobrel"

lemma "todos P (rev xs) = todos P xs"
apply (induct xs)
apply (simp_all add:todos_append)
by auto

-- "diecabmen1 irealetei juaruipav domlloriv marescpla jaisalmen zoiruicha"
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (auto simp add: todos_append)

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

--"irealetei maresccas4"
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix xs a
assume HI:"todos P (rev xs) = todos P xs"
have "todos P (rev (a # xs)) = todos P (rev xs @ [a])" by simp
also have "... = ( P a ∧ todos P (rev xs))" by (simp add:todos_append) auto
also have "... = ( P a ∧ todos P xs)" using HI by simp
finally show "todos P (rev (a # xs))= todos P (a#xs)" by simp
qed
(* pabflomar: Irene, la primera línea es prescindible
irealetei: Ya pero lo veo más claro así ^_^O *)

-- "pabflomar domlloriv"
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a # xs)) = (P a ∧ todos P (rev xs))" by (simp add:todos_append) auto
also have "... = (P a ∧ todos P xs)" using HI by simp
finally show "todos P (rev (a # xs)) = todos P (a # xs)" by simp
qed

-- "diecabmen1 jaisalmen zoiruicha"
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "todos P (rev (a#xs)) = todos P (rev xs @ [a])" by simp
also have "… = (todos P (rev xs) ∧ todos P [a])" by (simp add: todos_append)
also have "… = (todos P xs ∧ todos P [a])" using HI by simp
finally show "?P (a#xs)" by auto
qed

-- "juaruipav marescpla"
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show " todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have " todos P (rev (a # xs))= todos P ((rev xs)@[a])" by simp
also have "...= (todos P (rev xs)∧todos P [a])" by (simp add:todos_append)
also have "...= (todos P xs ∧todos P [a])" using HI by simp
also have "...= (todos P[a]∧todos P xs)" by auto
also have "...= todos P ([a]@xs)" by (simp add:todos_append)
also have "...= todos P (a#xs)" by simp
finally show "todos P (rev (a # xs)) = todos P (a#xs)" by simp
qed

--"ya veo que me he vuelto a complicar la vida (marescpla) jajaja"

--"julrobrel: sin usar auto"
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a#xs)) = todos P (rev xs @ rev [a])" by simp
also have "...=(todos P (rev xs) ∧ todos P (rev [a]))" by (simp add: todos_append)
also have "...=(todos P xs ∧ P a)" using HI by simp
also have "...=(P a ∧ todos P xs)" by (simp add: conj_commute)
also have "...=(todos P [a] ∧ todos P xs)" by simp
also have "...=(todos P ([a]@xs))" by simp
finally show "todos P (rev (a#xs)) = (todos P (a#xs))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar o refutar:
algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)
---------------------------------------------------------------------
*}

--"irealetei"
(*lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp
next
fix a xs
assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
have " algunos (λx. P x ∧ Q x) (a # xs) =((P a ∧ Q a) ∨ algunos (λx. P x ∧ Q x) xs)" by simp
also have "... = ((P a ∧ Q a) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp
--"Me da que esto es falso"
qed*)

(* irealetei: Me ha gustado la solución de maresccas4 diecabmen1 y me uno *)
(* juaruipav: Antes de empezar la demostración, quickcheck te avisa del contraejemplo*)
-- "maresccas4 diecabmen1 irealetei pabflomar juaruipav domlloriv marescpla julrobrel jaisalmen zoiruicha"
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
quickcheck
oops
(* Contraejemplo:
P = {a⇣1}
Q = {a⇣2}
xs = {a⇣1, a⇣2}
*)

text {*
---------------------------------------------------------------------
Ejercicio 7.1. Demostrar o refutar automáticamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

-- "irealetei maresccas4 pabflomar domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) auto

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

-- "irealetei diecabmen1 maresccas4 juaruipav domlloriv marescpla"
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI:"algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = algunos P (f a # (map f xs))" by simp
also have "... = (P (f a) ∨ algunos P (map f xs))" by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by simp
also have "... = ((P ∘ f) a ∨ algunos (P ∘ f) xs)" by simp
finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp
qed

-- "pabflomar"
(* pabflomar: A mi al menos me resulta más cómoda mi versión, con menos "pasos intermedios" *)

lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a # xs)) = (P (f a) ∨ algunos P (map f xs))" by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by simp
finally show "algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs) " by simp
qed

--"julrobrel"
lemma "algunos P (map f xs) = algunos (P ∘ f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a#xs)) = algunos P (f a # (map f xs))" by simp
also have "...=((P ∘ f) a ∨ algunos P (map f xs))" by simp
also have "...=((P ∘ f) a ∨ algunos (P ∘ f) xs)" using HI by simp
finally show "algunos P (map f (a#xs)) = algunos (P ∘ f) (a#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

-- "irealetei diecabmen1 maresccas4 pabflomar domlloriv juaruipav marescpla julrobrel jaisalmen zoiruicha"
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) auto

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

-- "irealetei maresccas4 pabflomar juaruipav domlloriv marescpla julrobrel"
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have " algunos P ((a # xs) @ ys) = (P a ∨ algunos P (xs @ys))" by simp
also have "... = (P a ∨ algunos P xs ∨ algunos P ys)" using HI by simp
finally show "algunos P ((a # xs) @ ys) = (algunos P (a # xs) ∨ algunos P ys)" by simp
qed

-- "diecabmen1 jaisalmen zoiruicha"
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?P xs ys")
proof (induct xs)
show "?P [] ys" by simp
next
fix a xs
assume HI: "?P xs ys"
have "algunos P ((a#xs) @ ys) = algunos P (a # xs @ ys) " by simp
also have "… = (P a ∨ algunos P (xs @ ys))" by simp
also have "… = (P a ∨ algunos P xs ∨ algunos P ys)" using HI by simp
finally show "?P (a#xs) ys" by simp
qed

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

-- "irealetei diecabmen1 pabflomar juaruipav domlloriv marescpla julrobrel jaisalmen zoiruicha"
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs) (auto simp add:algunos_append)

-- "maresccas4"

lemma "algunos P (rev xs) = algunos P xs"
apply (induct xs)
apply (simp_all add:algunos_append)
by auto

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

--"irealetei maresccas4 domlloriv"
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI:"algunos P (rev xs) = algunos P xs"
have " algunos P (rev (a # xs))= algunos P (rev xs @ [a])" by simp
also have "... = (P a ∨ algunos P (rev xs))" by (simp add:algunos_append) auto
also have "... = (P a ∨ algunos P xs)" using HI by simp
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

-- "pabflomar"
(* ṕabflomar: Yo sigo empeñado en lo mismo, la primera linea sobra, ¿qué mas da el orden en el que verifiques el primer elemento de una lista?*)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a # xs)) = (P a ∨ algunos P (rev xs))" by (simp add:algunos_append) auto
also have "... = (P a ∨ algunos P xs)" using HI by simp
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

-- "diecabmen1 marescpla jaisalmen zoiruicha"
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (rev (a#xs)) = algunos P (rev xs @ [a])" by simp
also have "… = (algunos P (rev xs) ∨ algunos P [a])" by (simp add: algunos_append)
also have "… = (algunos P xs ∨ algunos P [a])" using HI by simp
finally show "?P (a#xs)" by auto
qed

-- "juaruipav"
(* juaruipav: Versión con más "pasos intermedios" (eso que no le gusta a pabflomar),
yo lo veo más útil a la hora de interpretar el código. En otro caso utilizariamos la versión automática *)

lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show " algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI: "algunos P (rev xs) = algunos P xs"
have " algunos P (rev (a # xs))= algunos P ((rev xs)@[a])" by simp
also have "...= (algunos P (rev xs)∨ algunos P [a])" by (simp add:algunos_append)
also have "...= (algunos P xs ∨ algunos P [a])" using HI by simp
also have "...= (algunos P[a]∨ algunos P xs)" by auto
also have "...= algunos P ([a]@xs)" by (simp add:todos_append)
also have "...= algunos P (a#xs)" by simp
finally show "algunos P (rev (a # xs)) = algunos P (a#xs)" by simp
qed

--"julrobrel: sin auto"
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a#xs)) = algunos P ((rev xs) @ [a])" by simp
also have "...=(algunos P (rev xs) ∨ algunos P [a])" by (simp add:algunos_append)
also have "...=(algunos P xs ∨ algunos P [a])" using HI by simp
also have "...=(algunos P [a] ∨ algunos P xs)" by (simp add:disj_commute)
also have "...=(algunos P (a#xs))" by simp
finally show "algunos P (rev (a#xs)) = algunos P (a#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la
siguiente ecuación:
algunos (λx. P x ∨ Q x) xs = Z
y demostrar la equivalencia de forma automática y detallada.
---------------------------------------------------------------------
*}

--"irealetei diecabmen1 maresccas4 marescpla julrobrel domlloriv jaisalmen zoiruicha"
lemma "algunos (λx. P x ∨ Q x) xs =(algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

lemma "algunos (λx. P x ∨ Q x) xs =(algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show " algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp
next
fix a xs
assume HI:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
have " algunos (λx. P x ∨ Q x) (a # xs) = ((P a ∨ Q a) ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = ((P a ∨ Q a) ∨ (algunos P xs ∨ algunos Q xs))" using HI by simp
also have "... = (P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)" by auto
finally show " algunos (λx. P x ∨ Q x) (a # xs) = (algunos P (a # xs) ∨ algunos Q (a # xs))" by simp
qed

--"marescpla: encima de largo, me da error xD pero bueno"
lemma "algunos (λx. P x ∨ Q x) xs = algunos (λx. P x) xs ∨ algunos (λx. Q x) xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix x xs
assume HI: "?P xs"
have "algunos (λx. P x ∨ Q x) (x#xs) = ((λx. P x ∨ Q x) x ∨ algunos (λx. P x ∨ Q x) xs)" by (simp only: algunos.simps(2))
also have "... = ((λx. P x ∨ Q x) x ∨ algunos (λx. P x) xs ∨ algunos (λx. Q x) xs)"using HI by simp
also have "...=((P x) ∨ (Q x) ∨ algunos (λx. P x) xs ∨ algunos (λx. Q x) xs)" by simp
also have "...=((P x) ∨ algunos (λx. P x) xs ∨ (Q x) ∨ algunos (λx. Q x) xs)" by auto
also have "...=(algunos (λx. P x) (x#xs) ∨ algunos (λx. Q x) (x#xs))" by simp
finally show "?P (x#xs)" by auto
qed

--"julrobrel: sin usar auto"
lemma "algunos (λx. P x ∨ Q x) xs =(algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp
next
fix a xs
assume HI: "algunos (λx. P x ∨ Q x) xs =(algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a#xs)=(algunos (λx. P x ∨ Q x) [a] ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "...=(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "...=(P a ∨ Q a ∨ (algunos P xs ∨ algunos Q xs))" using HI by simp
also have "...=(P a ∨ (Q a ∨ algunos P xs) ∨ algunos Q xs)" by simp
also have "...=(P a ∨ (algunos P xs ∨ Q a) ∨ algunos Q xs)" by (simp add:disj_commute)
also have "...=(P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)" by simp
finally show "algunos (λx. P x ∨ Q x) (a#xs)=(algunos P (a#xs) ∨ algunos Q (a#xs))" by simp
qed

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

-- "irealetei diecabmen1 maresccas4 juaruipav pabflomar marescpla julrobrel domlloriv jaisalmen zoiruicha"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) auto

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

--"irealetei maresccas4 domlloriv"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"
have "algunos P (a # xs) = (P a ∨ algunos P xs)" by simp
also have "... = (P a ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp
also have "... = (¬(¬P a ∧ ¬¬ todos (λx. ¬ P x) xs))" by simp
also have "... = (¬(¬P a ∧ todos (λx. ¬ P x) xs))" by simp
finally show "algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # xs))" by simp
qed

-- "diecabmen1 marescpla jaisalmen zoiruicha"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "algunos P (a#xs) = (P a ∨ algunos P xs)" by simp
also have "… = (P a ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
finally show "?P (a#xs)" by simp
qed

-- "juaruipav pabflomar"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI: " algunos P xs = (¬ todos (λx. ¬ P x) xs)"
have "algunos P (a # xs) = (P a ∨ algunos P xs)" by simp
also have "...= (P a ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp
finally show " algunos P (a # xs) = (¬ todos (λx. ¬ P x) (a # xs))" by simp
qed

--"julrobrel"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (a # xs) = (algunos P [a] ∨ algunos P xs)" by simp
also have "...=(P a ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "...=(¬(¬P a ∧ todos (λx. (¬ P x)) xs))" by simp
finally show "algunos P (a # xs) =(¬ (todos (λx. (¬ P x)) (a#xs)))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

--"irealetei diecabmen1 maresccas4 pabflomar marescpla julrobrel domlloriv juaruipav jaisalmen zoiruicha"
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False"
|"estaEn x (a # xs) = (a=x ∨ estaEn x xs)"

value "estaEn (2::nat) [3,2,4]" -- "True"
value "estaEn (1::nat) [3,2,4]" -- "False"

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

fun igual :: "'a ⇒ 'a ⇒ bool" where
"igual x y = (x=y)"

lemma "(algunos (igual x) xs) = (estaEn x xs)"
by (induct xs) auto

lemma "(algunos (igual x) xs) = (estaEn x xs)"
proof (induct xs)
show " algunos (igual x) [] = estaEn x []" by simp
next
fix a xs
assume HI:"algunos (igual x) xs = estaEn x xs"
have "algunos (igual x) (a # xs) = (igual x a ∨ algunos (igual x) xs)" by simp
also have "... = (igual x a ∨ estaEn x xs)" using HI by simp
finally show "algunos (igual x) (a # xs) = (estaEn x (a#xs))" by simp auto
qed

-- "diecabmen1 marescpla julrobrel domlloriv juaruipav"
lemma "estaEn a xs = algunos (λx. (x=a)) xs"
by (induct xs) auto

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

-- "maresccas4"
-- "jaisalmen zoiruicha"
lemma "algunos (λx. x=a) xs = estaEn a xs"
proof (induct xs)
show "algunos (λx. x=a) [] = estaEn a []" by simp
next
fix y xs
assume HI: "algunos (λx. x=a) xs = estaEn a xs"
have "algunos (λx. x=a) (y#xs) = (y=a ∨ algunos (λx. x=a) xs)" by simp
also have "... = (y=a ∨ estaEn a xs)" using HI by simp
finally show "algunos (λx. x=a) (y#xs) = estaEn a (y#xs)" by simp
qed

-- "pabflomar"
(* Equivalente a la de diecabmen1, sin predicados.*)

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

lemma "estaEn a xs = algunos (λx. x=a) xs"
proof (induct xs)
show "estaEn a [] = algunos (λx. x = a) []" by simp
next
fix aa xs
assume HI: "estaEn a xs = algunos (λx. x = a) xs"
have "estaEn a (aa # xs) = ( a=aa ∨ estaEn a xs)" by simp
also have "... = (a=aa ∨ algunos (λx. x = a) xs)" using HI by simp
finally show "estaEn a (aa # xs) = algunos (λx. x = a) (aa # xs)" by auto
qed

--"julrobrel: sin usar auto"
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
show "algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (a # xs) = (algunos P [a] ∨ algunos P xs)" by simp
also have "...=(P a ∨ (¬ todos (λx. (¬ P x)) xs))" using HI by simp
also have "...=(¬(¬P a ∧ todos (λx. (¬ P x)) xs))" by simp
finally show "algunos P (a # xs) =(¬ (todos (λx. (¬ P x)) (a#xs)))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 14. Definir la función primitiva recursiva
sinDuplicados :: 'a list ⇒ bool
tal que (sinDuplicados xs) se verifica si la lista xs no contiene
duplicados. Por ejemplo,
sinDuplicados [1::nat,4,2] = True
sinDuplicados [1::nat,4,2,4] = False
---------------------------------------------------------------------
*}

-- "diecabmen1"
fun sinDuplicados' :: "'a ⇒'a list ⇒ bool" where
"sinDuplicados' a [] = True"
| "sinDuplicados' a (x#xs) = (a≠x ∧ sinDuplicados' a xs)"

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

value "sinDuplicados [1::nat,4,2]"
value "sinDuplicados [1::nat,4,2,4]"

-- "maresccas4 pabflomar marescpla julrobrel domlloriv irealetei juaruipav jaisalmen zoiruicha"
fun sinDuplicados2 :: "'a list ⇒ bool" where
"sinDuplicados [] = True"
| "sinDuplicados (x#xs) = (¬estaEn x xs ∧ sinDuplicados xs)"

text {*
---------------------------------------------------------------------
Ejercicio 15. Definir la función primitiva recursiva
borraDuplicados :: 'a list ⇒ bool
tal que (borraDuplicados xs) es la lista obtenida eliminando los
elementos duplicados de la lista xs. Por ejemplo,
borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]

Nota: La función borraDuplicados es equivalente a la predefinida
remdups.
---------------------------------------------------------------------
*}

-- "diecabmen1"
fun borraDuplicados :: "'a list ⇒ 'a list" where
"borraDuplicados [] = []"
| "borraDuplicados (x#xs) = (if x ∈ set xs then borraDuplicados xs else x#borraDuplicados xs)"

value " borraDuplicados [1::nat,2,4,2,3]"

-- "maresccas4 irealetei pabflomar marescpla julrobrel domlloriv juaruipav jaisalmen zoiruicha"
fun borraDuplicados2 :: "'a list ⇒ 'a list" where
"borraDuplicados2 [] = []"
| "borraDuplicados2 (x#xs) = (if estaEn x xs then borraDuplicados2 xs else x # borraDuplicados2 xs)"

(* irealetei: así tambien lo hice, pero no me terminaba de gustar y lo cambié usando el "if"*)
fun borraDuplicados3 :: "'a list => 'a list" where
"borraDuplicados3 [] = []"
| "borraDuplicados3 (x#xs) = (case estaEn x xs of True => borraDuplicados3 xs | False => x#borraDuplicados3 xs)"

text {*
---------------------------------------------------------------------
Ejercicio 16.1. Demostrar o refutar automáticamente
length (borraDuplicados xs) ≤ length xs
---------------------------------------------------------------------
*}

-- "diecabmen1 maresccas4 irealetei pabflomar marescpla domlloriv julrobrel juaruipav jaisalmen zoiruicha"

lemma length_borraDuplicados:
"length (borraDuplicados xs) ≤ length xs"
by (induct xs) auto

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

-- "diecabmen1"
lemma length_borraDuplicados2:
"length (borraDuplicados xs) ≤ length xs" (is "?P xs")
proof (induct xs)
show "?P []" by simp
next
fix a xs
assume HI: "?P xs"
have "length (a#xs) = Suc 0 + length xs" by simp
also have "length (borraDuplicados (a#xs)) = length (if a ∈ set xs then borraDuplicados xs else a#borraDuplicados xs)" by simp
have "length xs ≤ Suc 0 + length xs" using HI by simp
have "length (a#borraDuplicados xs) ≤ Suc 0 + length xs "using HI by simp
finally show "?P (a#xs)" by simp
qed

-- "maresccas4 irealetei marescpla domlloriv pabflomar juaruipav"
(* pabflomar: A la hora de fijar x y xs no es necesario especificar los tipos.*)
lemma
"length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix x :: "'a"
fix xs :: "'a list"
assume HI: "length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (x#xs)) ≤ 1 + length (borraDuplicados xs)" by simp
also have "... ≤ 1 + length xs" using HI by simp
finally show "length (borraDuplicados (x#xs)) ≤ length (x#xs)" by simp
qed

--"julrobrel jaisalmen zoiruicha"
lemma "length (borraDuplicados xs) ≤ length xs"
proof (induct xs)
show "length (borraDuplicados []) ≤ length []" by simp
next
fix a xs
assume HI:"length (borraDuplicados xs) ≤ length xs"
have "length (borraDuplicados (a # xs)) ≤ 1 + length (borraDuplicados (xs))" by simp
also have "...≤ 1 + length xs" using HI by simp
finally show "length (borraDuplicados (a # xs)) ≤ length (a#xs)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 17.1. Demostrar o refutar automáticamente
estaEn a (borraDuplicados xs) = estaEn a xs
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei marescpla diecabmen1 julrobrel domlloriv juaruipav jaisalmen zoiruicha"
lemma "estaEn a (borraDuplicados2 xs) = estaEn a xs"
by (induct xs) auto

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

-- "maresccas4"
lemma estaEn_borraDuplicados:
"estaEn a (borraDuplicados2 xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados2 []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados2 xs) = estaEn a xs"
have "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (if estaEn x xs then borraDuplicados2 xs else x # borraDuplicados2 xs)" by simp
also have "... = (if estaEn x xs then estaEn a (borraDuplicados2 xs) else estaEn a (x#borraDuplicados2 xs))" by simp
also have "... = (if estaEn x xs then estaEn a xs else (x=a ∨ estaEn a xs))" using HI by simp
also have "... = (if estaEn x xs then estaEn a xs else estaEn a (x#xs))" by simp
finally show "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (x#xs)" by auto
qed

-- "maesccas4 irealetei diecabmen1 domlloriv marescpla juaruipav jaisalmen zoiruicha"
lemma estaEn_borraDuplicados_porCasos:
"estaEn a (borraDuplicados2 xs) = estaEn a xs"
proof (induct xs)
show "estaEn a (borraDuplicados2 []) = estaEn a []" by simp
next
fix x xs
assume HI: "estaEn a (borraDuplicados2 xs) = estaEn a xs"
show "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (x#xs)"
proof (cases)
assume "estaEn x xs"
then have "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (borraDuplicados2 xs)" by simp
also have "...= estaEn a xs" using HI by simp
finally show "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (x#xs)" by auto
next
assume "¬estaEn x xs"
then have "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (x#borraDuplicados2 xs)" by simp
also have "...= (x = a ∨ estaEn a (borraDuplicados2 xs))" by simp
finally show "estaEn a (borraDuplicados2 (x#xs)) = estaEn a (x#xs)" using HI by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 18.1. Demostrar o refutar automáticamente
sinDuplicados (borraDuplicados xs)
---------------------------------------------------------------------
*}

-- "maresccas4 irealetei diecabmen1 julrobrel domlloriv marescpla juaruipav jaisalmen zoiruicha"
lemma "sinDuplicados (borraDuplicados xs)"
by (induct xs) (auto simp add: estaEn_borraDuplicados)

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

-- "maresccas4"
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados2 xs)"
proof (induct xs)
show "sinDuplicados (borraDuplicados2 [])" by simp
next
fix x :: "'a"
fix xs :: "'a list"
assume HI: "sinDuplicados (borraDuplicados2 xs)"
have "sinDuplicados (borraDuplicados2 (x#xs)) = sinDuplicados ((if estaEn x xs then borraDuplicados2 xs else x # borraDuplicados2 xs))" by simp
also have "...= (if estaEn x xs then sinDuplicados (borraDuplicados2 xs) else sinDuplicados (x#borraDuplicados2 xs))" by simp
also have "...= (if estaEn x xs then sinDuplicados (borraDuplicados2 xs) else (¬estaEn x (borraDuplicados2 xs) ∧ sinDuplicados (borraDuplicados2 xs)))" by simp
also have "...= (if estaEn x xs then sinDuplicados (borraDuplicados2 xs) else (¬estaEn x xs ∧ sinDuplicados (borraDuplicados2 xs)))" by (simp add: estaEn_borraDuplicados)
then show "sinDuplicados (borraDuplicados2 (x#xs))" using HI by (simp add: estaEn_borraDuplicados)
qed

lemma sinDuplicados_borraDuplicados_porCasos:
"sinDuplicados (borraDuplicados2 xs)"
proof (induct xs)
show "sinDuplicados (borraDuplicados2 [])" by simp
next
fix x :: "'a"
fix xs :: "'a list"
assume HI: "sinDuplicados (borraDuplicados2 xs)"
show "sinDuplicados (borraDuplicados2 (x#xs))"
proof (cases)
assume h1: "estaEn x xs"
have "sinDuplicados (borraDuplicados2 (x#xs)) = sinDuplicados ((if estaEn x xs then borraDuplicados2 xs else x # borraDuplicados2 xs))" by simp
also have "...= sinDuplicados (borraDuplicados2 xs)" using h1 by simp
finally show "sinDuplicados (borraDuplicados2 (x#xs))" using HI by simp
next
assume h2: "¬estaEn x xs"
have "sinDuplicados (borraDuplicados2 (x#xs)) = sinDuplicados ((if estaEn x xs then borraDuplicados2 xs else x # borraDuplicados2 xs))" by simp
also have "...= sinDuplicados (x#borraDuplicados2 xs)" using h2 by simp
also have "...= (¬estaEn x xs ∧ sinDuplicados (borraDuplicados2 xs))" by (simp add: estaEn_borraDuplicados)
also have "...= sinDuplicados (borraDuplicados2 xs)" using h2 by simp
finally show "sinDuplicados (borraDuplicados2 (x#xs))" using HI by simp
qed
qed

--"irealetei diecabmen1 domlloriv marescpla juaruipav jaisalmen zoiruicha"
lemma sinDuplicados_borraDuplicados:
"sinDuplicados (borraDuplicados xs)"
proof (induct xs)
show "sinDuplicados (borraDuplicados [])" by simp
next
fix a::"'a"
fix xs::"'a list"
assume HI:"sinDuplicados (borraDuplicados xs)"
show "sinDuplicados (borraDuplicados (a # xs))"
proof (cases)
assume "estaEn a xs"
then have "sinDuplicados (borraDuplicados (a # xs)) = sinDuplicados (borraDuplicados xs)" by simp
also have "... = True" using HI by simp
finally show "sinDuplicados (borraDuplicados (a # xs))" by simp
next
assume HI2:"¬estaEn a xs"
then have "sinDuplicados (borraDuplicados (a # xs)) = sinDuplicados (a # borraDuplicados xs)" by simp
also have "... = (¬estaEn a (borraDuplicados xs) ∧ sinDuplicados(borraDuplicados xs))" by simp
also have "... = (¬estaEn a (borraDuplicados xs) ∧ True)" using HI by simp
also have "...= (¬estaEn a xs)" by (simp add:estaEn_borraDuplicados)
finally show "sinDuplicados (borraDuplicados (a # xs))" using HI2 by simp
qed
qed

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

-- "maresccas4 irealetei diecabmen1 julrobrel domlloriv marescpla juaruipav jaisalmen zoiruicha"
lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"
quickcheck
oops
(* Contraejemplo:
xs = {a⇣1, a⇣2, a⇣1}
*)

end
</source>

Relación 12

2018-07-16T15:46:13Z

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

<source lang="isabelle">
header {* R12: Representación de fórmulas proposicionales mediante
polinomios *}

theory R12
imports Main
begin

text {*
El objetivo de esta relación es definir un procedimiento para
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en
polinomios de la forma
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)
y demostrar que, para cualquier interpretación I, el valor de las
fórmulas coincide con la de su correspondiente polinomio. *}

text {*
---------------------------------------------------------------------
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante
las siguientes reglas:
· ⊤ es una fórmula proposicional
· Las variables proposicionales p_1, p_2, … son fórmulas
proposicionales,
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)
también lo son.
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y
⊕ es la disyunción exclusiva.

Definir el tipo de datos form para representar las fórmulas
proposicionales usando
· T en lugar de ⊤,
· (Var i) en lugar de p_i,
· (And F G) en lugar de (F ∧ G) y
· (Xor F G) en lugar de (F ⊕ G).
------------------------------------------------------------------ *}

datatype form = T | Var nat | And form form | Xor form form

text {*
---------------------------------------------------------------------
Ejercicio 2. Los siguientes ejemplos de fórmulas
form1 = p0 ⊕ ⊤
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)
es usará en lo que sigue.
------------------------------------------------------------------ *}

abbreviation form1 :: "form" where
"form1 ≡ Xor (Var 0) T"
abbreviation form2 :: "form" where
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
xor :: bool ⇒ bool ⇒ bool
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por
ejemplo,
xor False True = True
------------------------------------------------------------------ *}

--"diecabmen1 irealetei pabflomar jaisalmen zoiruicha maresccas4 marescpla domlloriv"
-- "jaisalmen: http://es.wikipedia.org/wiki/Disyunci%C3%B3n_exclusiva"
-- "jaisalmen: de la definicion de xor: p xor q = ( p∧¬ q) or (¬ p ∧ q)"
definition xor :: "bool ⇒ bool ⇒ bool" where
"xor x y ≡ (x∧¬y)∨(¬x∧y)"

text {*
---------------------------------------------------------------------
Ejercicio 4. Una interpretación es una aplicación de los naturales en
los booleanos. Definir las siguientes interpretaciones
| p0 | p1 | p2 | p3 | ...
int1 | F | F | F | F | ...
int2 | F | V | F | F | ...
int3 | V | F | F | F | ...
int3 | V | V | F | F | ...
------------------------------------------------------------------ *}

abbreviation int1 :: "nat ⇒ bool" where
"int1 x ≡ False"
abbreviation int2 :: "nat ⇒ bool" where
"int2 ≡ int1 (1 := True)"
abbreviation int3 :: "nat ⇒ bool" where
"int3 ≡ int1 (0 := True)"
abbreviation int4 :: "nat ⇒ bool" where
"int4 ≡ int1 (0 := True, 1 := True)"

text {*
---------------------------------------------------------------------
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F
repecto de I, I(F), se define por
· T, si F es ⊤;
· I(n), si F es p_n;
· I(G) ∧ I(H), si F es (G ∧ H);
· I(G) ⊕ I(H), si F es (G ⊕ H).

Definir la función
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool
tal que (valorF i f) es el valor de la fórmula f respecto de la
interpretación i. Por ejemplo,
valorF int1 form1 = True
valorF int3 form1 = False
valorF int1 form2 = False
valorF int2 form2 = True
valorF int3 form2 = True
valorF int4 form2 = True
--------------------------------------------------------------------- *}

--"diecabmen1 irealetei maresccas4 marescpla jaisalmen zoiruicha domlloriv"
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where
"valorF i T = True"
| "valorF i (Var n) = i n"
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"

text {*
---------------------------------------------------------------------
Ejercicio 6. Un monomio es una lista de números naturales y se puede
interpretar como la conjunción de variables proposionales cuyos
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]
se interpreta como la fórmula (p0 ∧ p2 ∧ p1).

Definir la función
formM :: nat list ⇒ form
tal que (formM m) es la fórmula correspondiente al monomio. Por
ejemplo,
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))
--------------------------------------------------------------------- *}

--"diecabmen1 irealetei maresccas4 marescpla jaisalmen zoiruicha domlloriv"
fun formM :: "nat list ⇒ form" where
"formM [] = T"
| "formM (x#xs) = And (Var x) (formM xs)"

value "formM [0,2,1]"

text {*
---------------------------------------------------------------------
Ejercicio 7. Definir, por recursión, la función
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool
tal que (valorM i m) es el valor de la fórmula representada por el
monomio m en la interpretación i. Por ejemplo,
valorM int1 [0,2,1] = False
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True
Demostrar que, para toda interpretación i y todo monomio m, se tiene
que
valorM i m = valorF i (formM m)
--------------------------------------------------------------------- *}

--"diecabmen1 irealetei maresccas4 marescpla"
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where
"valorM i [] = True"
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))" --"Aquí he quitado algún paréntesis, pero la solución es, en esencia, la misma."

value "valorM int1 [0,2,1]"
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"

--"diecabmen1 irealetei domlloriv"
lemma correccion_valorM:
"valorM i m = valorF i (formM m)"
by (induct m) auto

--"diecabmen1"
lemma correccion_valorM2:
"valorM i m = valorF i (formM m)" (is "?P i m")
proof (induct m)
show "?P i []" by simp
next
fix a m
assume HI: "?P i m"
then show "?P i (a#m)" by simp
qed

--"irealetei maresccas4 marescpla"
lemma correccion_valorM_detalle:
"valorM i m = valorF i (formM m)"
proof (induct m)
show "valorM i [] = valorF i (formM [])" by simp
next
fix a m
assume HI:"valorM i m = valorF i (formM m)"
have "valorM i (a # m) = (valorF i (Var a) ∧ valorM i m)" by simp
also have "... = (valorF i (Var a) ∧ valorF i (formM m))" using HI by simp
also have "... = valorF i (formM (a # m))" by simp
finally show "valorM i (a # m) = valorF i (formM (a # m))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 8. Un polinomio es una lista de monomios y se puede
interpretar como la disyunción exclusiva de los monomios. Por ejemplo,
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).

Definir la función
formP :: nat list list ⇒ form
tal que (formP p) es la fórmula correspondiente al polinomio p. Por
ejemplo,
formP [[1,2],[3]]
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))
--------------------------------------------------------------------- *}

--"diecabmen1 irealetei maresccas4 marescpla domlloriv"
fun formP :: "nat list list ⇒ form" where
"formP [] = Xor T T"
| "formP (x#xs) = Xor (formM x) (formP xs)"

value "formP [[1,2],[3]]"

text {*
---------------------------------------------------------------------
Ejercicio 9. Definir la función
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool
tal que (valorP i p) es el valor de la fórmula representada por el
polinomio p en la interpretación i. Por ejemplo,
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True
Demostrar que, para toda interpretación i y todo polinomio p, se tiene
que
valorM i p = valorF i (formP p)
--------------------------------------------------------------------- *}

--"diecabmen1 irealetei"
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where
"valorP i [] = xor True True"
| "valorP i (x#xs) = xor (valorM i x) (valorP i xs)"

value "valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]]"
lemma correccion_valorP:
"valorP i p = valorF i (formP p)"
by (induct p) (auto simp add:correccion_valorM)

-- "irealetei"
lemma correccion_valorP_detalle:
"valorP i p = valorF i (formP p)"
proof (induct p)
show "valorP i [] = valorF i (formP [])" by simp
next
fix a p
assume HI:"valorP i p = valorF i (formP p)"
have "valorP i (a # p) = xor (valorM i a) (valorP i p)" by simp
also have "... = xor (valorF i (formM a)) (valorP i p) " by (simp add:correccion_valorM)
also have "... = xor (valorF i (formM a)) (valorF i (formP p))" using HI by simp
also have "... = valorF i (formP (a # p))" by simp
finally show " valorP i (a # p) = valorF i (formP (a # p))" by simp
qed

-- "maresccas4"
fun valorP4 :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where
"valorP4 i [] = False"
| "valorP4 i (x#xs) = xor (valorM i x) (valorP4 i xs)"

value "valorP4 (int1(1:=True,3:=True)) [[0,2,1],[1,3]]"

lemma correccion_valorP4:
"valorP4 i p = valorF i (formP p)"
proof (induct p)
show "valorP4 i [] = valorF i (formP [])" by (simp add:xor_def)
next
fix x xs
assume HI: "valorP4 i xs = valorF i (formP xs)"
have "valorP4 i (x#xs) = xor (valorM i x) (valorP4 i xs)" by simp
also have "... = xor (valorM i x) (valorF i (formP xs))" using HI by simp
also have "... = valorF i (Xor (formM x) (formP xs))" by (simp add: correccion_valorM)
also have "... = valorF i (formP (x#xs))" by simp
finally show "valorP4 i (x#xs) = valorF i (formP (x#xs))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir la función
productoM :: nat list ⇒ nat list list ⇒ nat list list
tal que (productoM m p) es el producto del monomio p por el polinomio
p. Por ejemplo,
productoM [1,3] [[1,2,4],[7],[4,1]]
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]
--------------------------------------------------------------------- *}

--"diecabmen1"
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where
"productoM m [] = []"
| "productoM m (x#xs) = [m@x] @ (productoM m xs)"

--"irealetei maresccas4"
fun productoM2 :: "nat list ⇒ nat list list ⇒ nat list list" where
"productoM2 m [] = []"
| "productoM2 m (a#ns) = (m@a)#(productoM2 m ns)"

value "productoM [1,3] [[1,2,4],[7],[4,1]]"

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor
de la concatenación de dos monomios es la conjunción de sus valores.
--------------------------------------------------------------------- *}

--"diecabmen1"
lemma valorM_conc:
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)" (is "?P i xs ys")
proof (induct xs)
show "?P i [] ys" by simp
next
fix a xs
assume HI: "?P i xs ys"
then show "?P i (a#xs) ys" by simp
qed

--"irealetei maresccas4"
lemma valorM_conc_auto:
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"
by (induct xs) auto

lemma valorM_conc_detalle:
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"
proof (induct xs)
show "valorM i ([] @ ys) = (valorM i [] ∧ valorM i ys)" by simp
next
fix a xs
assume HI:"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"
have "valorM i ((a # xs) @ ys) = (valorF i (Var a) ∧ valorM i (xs @ ys))" by simp
also have "... = (valorF i (Var a) ∧ (valorM i xs ∧ valorM i ys))" using HI by simp
also have "... = (valorM i (a # xs) ∧ valorM i ys)" by simp
finally show "valorM i ((a # xs) @ ys) = (valorM i (a # xs) ∧ valorM i ys)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor
del producto de un monomio por un polinomio es la conjunción de sus
valores.
--------------------------------------------------------------------- *}

--"irealetei"

lemma xor_compl: "xor (a ∧ p) (a ∧ q) = (a ∧ (xor p q))"
proof -
have "xor (a ∧ p) (a ∧ q) = (((a ∧ p) ∧ ¬(a ∧ q)) ∨ (¬(a ∧ p) ∧ (a ∧ q)))" by (simp add:xor_def)
also have "... = (a ∧ ((p ∧ ¬q) ∨ (¬p ∧ q)))" by auto
also have "... = (a ∧ (xor p q))" by (simp add:xor_def)
finally show "xor (a ∧ p) (a ∧ q) = (a ∧ (xor p q))" by simp
qed

-- "No me hacía falta definir el xor_neg, anterior, que es como matar moscas a cañonazos"
lemma correccion_productoM:
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"
proof (induct p)
have "valorP i (productoM m []) = valorP i []" by simp
also have "... = (valorM i m ∧ valorP i [])" by (simp add:xor_def)
then show "valorP i (productoM m []) = (valorM i m ∧ valorP i [])" by simp
next
fix a p
assume HI:"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"
have "valorP i (productoM m (a # p)) = valorP i ((m@a)#(productoM m p))" by simp
also have "... = xor (valorM i (m@a)) (valorP i (productoM m p))" by simp
also have "... = xor (valorM i (m@a)) (valorM i m ∧ valorP i p)" using HI by simp
also have "... = xor (valorM i m ∧ valorM i a) (valorM i m ∧ valorP i p)" by (simp add:valorM_conc)
also have "... = (valorM i m ∧ xor (valorM i a) (valorP i p))" by (simp add:xor_compl)
also have "... = (valorM i m ∧ valorP i (a # p))" by simp
finally show "valorP i (productoM m (a # p)) = (valorM i m ∧ valorP i (a # p))" by simp
qed

lemma correccion_productoM_auto:
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"
by (induct p) (auto simp add:xor_def valorM_conc xor_compl)

-- "maresccas4"
lemma lema1: "xor (a ∧ b) (a ∧ c) = (a ∧ (xor b c))"
proof (cases a)
assume H: "a"
then show "xor (a ∧ b) (a ∧ c) = (a ∧ (xor b c))" by simp
next
assume H: "¬a"
then show "xor (a ∧ b) (a ∧ c) = (a ∧ (xor b c))" by (simp add: xor_def)
qed

lemma correccion_productoM:
"valorP4 i (productoM m p) = (valorM i m ∧ valorP4 i p)"
proof (induct p)
show "valorP4 i (productoM m []) = (valorM i m ∧ valorP4 i [])" by simp
next
fix p px
assume HI: "valorP4 i (productoM m px) = (valorM i m ∧ valorP4 i px)"
have "valorP4 i (productoM m (p#px)) = valorP4 i ((m@p) # productoM m px)" by simp
also have "... = xor (valorF i (formM (m@p))) (valorP4 i (productoM m px))" by (simp add: correccion_valorM)
also have "... = xor (valorF i (formM (m@p))) (valorM i m ∧ valorP4 i px)" using HI by simp
also have "... = xor (valorM i (m @ p)) (valorM i m ∧ valorP4 i px)" by (simp add: correccion_valorM)
also have "... = xor (valorM i m ∧ valorM i p) (valorM i m ∧ valorP4 i px)" by (simp add: valorM_conc)
also have "... = (valorM i m ∧ (xor (valorM i p) (valorP4 i px)))" by (simp add: lema1)
also have "... = (valorM i m ∧ valorP4 i (p#px))" by simp
finally show "valorP4 i (productoM m (p#px)) = (valorM i m ∧ valorP4 i (p#px))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 13. Definir la función
producto :: nat list list ⇒ nat list list ⇒ nat list list
tal que (producto p q) es el producto de los polinomios p y q. Por
ejemplo,
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]
--------------------------------------------------------------------- *}

--"irealetei: tenía una de más que no valía para nada, se me queda igual que maresccas4"

fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where
"producto [] q = []"
| "producto (a1 # p) (q) = (productoM a1 q)@(producto p q)"

value "producto [[1,3],[2]] [[1,2,4],[7],[4,1]]"

-- "maresccas4"
fun producto4 :: "nat list list ⇒ nat list list ⇒ nat list list" where
"producto [] q = []"
| "producto (m#p) q = (productoM m q) @ (producto p q)"

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor
de la concatenación de dos polinomios es la disyunción exclusiva de
sus valores.
--------------------------------------------------------------------- *}

-- "maresccas4 irealetei"

-- "Si me da tiempo, intentaré probar este lema. Irealetei: lo estoy intentando pero me he quedado en: '((a ∧ (¬b ∨ c) ∧ (b∨¬c)) ∨ (¬a ∧ ((b∧¬c) ∨ (¬b∧c ))))' y me va a petar el cerebro..."

lemma lema2: "xor a (xor b c) = xor (xor a b) c"
by (auto simp add: xor_def)

-- "Me ha dado tiempo. De forma análoga al lema1"
lemma lema2_simp: "xor a (xor b c) = xor (xor a b) c"
proof (cases a)
assume "a"
show "xor a (xor b c) = xor (xor a b) c"
proof (cases b)
assume "b"
then show "xor a (xor b c) = xor (xor a b) c" using `a` by (simp add: xor_def)
next
assume "¬b"
then show "xor a (xor b c) = xor (xor a b) c" by (simp add: xor_def)
qed
next
assume "¬a"
show "xor a (xor b c) = xor (xor a b) c"
proof (cases b)
assume "b"
then show "xor a (xor b c) = xor (xor a b) c" using `¬a`by (simp add: xor_def)
next
assume "¬b"
then show "xor a (xor b c) = xor (xor a b) c" by (simp add: xor_def)
qed
qed

lemma valorP_conc:
"valorP4 i (xs @ ys) = (xor (valorP4 i xs) (valorP4 i ys))"
proof (induct xs)
show "valorP4 i ([] @ ys) = (xor (valorP4 i []) (valorP4 i ys))" by (simp add: xor_def)
next
fix x xs
assume HI: "valorP4 i (xs @ ys) = (xor (valorP4 i xs) (valorP4 i ys))"
have "valorP4 i ((x#xs) @ ys) = valorP4 i (x # (xs@ys))" by simp
also have "... = xor (valorM i x) (valorP4 i (xs@ys))" by simp
also have "... = xor (valorM i x) (xor (valorP4 i xs) (valorP4 i ys))" using HI by simp
also have "... = xor (xor (valorM i x) (valorP4 i xs)) (valorP4 i ys)" by (simp add: lema2)
also have "... = xor (valorP4 i (x#xs)) (valorP4 i ys)" by simp
finally show "valorP4 i ((x#xs) @ ys) = (xor (valorP4 i (x#xs)) (valorP4 i ys))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor
del producto de dos polinomios es la conjunción de sus valores.
--------------------------------------------------------------------- *}

-- "maresccas4 irealetei"

-- "Es fácil ver que este lema es análogo al demostrado lema1"
lemma lema3: "xor (a ∧ c) (b ∧ c) = ((xor a b) ∧ c)"
by (auto simp add: xor_def)

lemma correccion_producto:
"valorP4 i (producto4 p q) = (valorP4 i p ∧ valorP4 i q)"
proof (induct p)
show "valorP4 i (producto4 [] q) = (valorP4 i [] ∧ valorP4 i q)" by simp
next
fix m p
assume HI: "valorP4 i (producto4 p q) = (valorP4 i p ∧ valorP4 i q)"
have "valorP4 i (producto4 (m#p) q) = valorP4 i ((productoM m q) @ (producto4 p q))" by simp
also have "... = (xor (valorP4 i (productoM m q)) (valorP4 i (producto4 p q)))" by (simp add: valorP_conc)
also have "... = (xor (valorP4 i (productoM m q)) (valorP4 i p ∧ valorP4 i q))" using HI by simp
also have "... = (xor (valorM i m ∧ valorP4 i q) (valorP4 i p ∧ valorP4 i q))" by (simp add: correccion_productoM)
also have "... = ((xor (valorM i m) (valorP4 i p)) ∧ valorP4 i q)" by (simp add: lema3)
also have "... = (valorP4 i (m#p) ∧ valorP4 i q)" by simp
finally show "valorP4 i (producto4 (m#p) q) = (valorP4 i (m#p) ∧ valorP4 i q)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 16. Definir la función
polinomio :: form ⇒ nat list list
tal que (polinomio f) es el polinomio que representa la fórmula f. Por
ejemplo,
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]
polinomio (And (Var 1) (Var 2)) = [[1,2]]
polinomio (Xor (Var 1) T) = [[1],[]]
polinomio (And (Var 1) T) = [[1]]]
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]
--------------------------------------------------------------------- *}

-- "maresccas4 irealetei"

fun polinomio :: "form ⇒ nat list list" where
"polinomio T = [[]]"
| "polinomio (Var a) = [[a]]"
| "polinomio (And G H) = producto4 (polinomio G) (polinomio H)"
| "polinomio (Xor G H) = (polinomio G) @ (polinomio H)"

value "polinomio (Xor (Var 1) (Var 2))"
value "polinomio (And (Var 1) (Var 2))"
value "polinomio (Xor (Var 1) T)"
value "polinomio (And (Var 1) T)"
value "polinomio (And (Xor (Var 1) (Var 2)) (Var 3))"
value "polinomio (Xor (And (Var 1) (Var 2)) (Var 3))"

text {*
---------------------------------------------------------------------
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor
de f es igual que el de su polinomio.
--------------------------------------------------------------------- *}

-- "maresccas4 irealetei"

theorem correccion_polinomio:
"valorF i f = valorP4 i (polinomio f)"
proof (induct f)
show "valorF i T = valorP4 i (polinomio T)" by (simp add: xor_def)
next
fix a
show "valorF i (Var a) = valorP4 i (polinomio (Var a))" by (simp add: xor_def)
next
fix G H
assume H1: "valorF i G = valorP4 i (polinomio G)"
assume H2: "valorF i H = valorP4 i (polinomio H)"
have "valorF i (And G H) = (valorF i G ∧ valorF i H)" by simp
also have "... = ((valorP4 i (polinomio G)) ∧ (valorP4 i (polinomio H)))" using H1 H2 by simp
also have "... = valorP4 i (producto4 (polinomio G) (polinomio H))" by (simp add: correccion_producto)
also have "... = valorP4 i (polinomio (And G H))" by simp
finally show "valorF i (And G H) = valorP4 i (polinomio (And G H))" by simp
next
fix G H
assume H1: "valorF i G = valorP4 i (polinomio G)"
assume H2: "valorF i H = valorP4 i (polinomio H)"
have "valorF i (Xor G H) = xor (valorF i G) (valorF i H)" by simp
also have "... = xor (valorP4 i (polinomio G)) (valorP4 i (polinomio H))" using H1 H2 by simp
also have "... = valorP4 i ((polinomio G) @ (polinomio H))" by (simp add: valorP_conc)
also have "... = valorP4 i (polinomio (Xor G H))" by simp
finally show "valorF i (Xor G H) = valorP4 i (polinomio (Xor G H))" by simp
qed

end
</source>

Relación 2

2018-07-16T15:46:13Z

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

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

theory R2
imports Main
begin

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

-- "maresccas4 pabflomar"

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

value "sumaImpares 5" -- "= 25"

-- "diecabmen1 irealetei juaruipav domlloriv, marescpla"
thm nat.induct
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0"
| "sumaImpares2 (Suc n) = (2*n + 1) + sumaImpares2 n" <-- "yo he puesto el +1 con un Suc (marescpla)"

value "sumaImpares2 5" -- "= 25"

-- "jaisalmen zoiruicha"
fun sumaImpares3 :: "nat ⇒ nat" where
"sumaImpares3 0 = 0"
| "sumaImpares3 (n) = (2 * n) - 1 + sumaImpares3 (n - 1)"

value "sumaImpares 5" -- "= 25"

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

-- "maresccas4,juaruipav domlloriv pabflomar, marescpla"

lemma "sumaImpares n = n*n"
by (induct n) auto

-- "diecabmen1 irealetei"

lemma "sumaImpares2 n = n*n"
by (induct n) auto

-- "jaisalmen zoiruicha"
lemma "sumaImpares3 n = n*n"
by (induct n) auto

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

-- "maresccas4 diecabmen1 irealetei domlloriv pabflomar, marescpla"

fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2"
|"sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n) + sumaPotenciasDeDosMasUno n"

value "sumaPotenciasDeDosMasUno 3" -- "= 16"

-- "juaruipav"
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2"
| "sumaPotenciasDeDosMasUno2 (Suc n) = 2*sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3" -- "= 16"

-- "jaisalmen zoiruicha"
fun sumaPotenciasDeDosMasUno3 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno3 0 = 2"
| "sumaPotenciasDeDosMasUno3 (n) = 2^n + sumaPotenciasDeDosMasUno3(n - 1)"

value "sumaPotenciasDeDosMasUno3 3" -- "= 16"

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

-- "maresccas4 diecabmen1 irealetei juaruipav domlloriv pabflomar jaisalmen, marescpla zoiruicha"

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

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

-- "maresccas4 irealetei domlloriv juaruipav pabflomar, marescpla"

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

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

-- "diecabmen1"

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

value "copia2 3 x" -- "= [x,x,x]"

-- "jaisalmen zoiruicha"
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []"
| "copia3 n x = x # (copia3 (n- 1) x)"

value "copia3 3 x" -- "= [x,x,x]"

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

-- "maresccas4 irealetei diecabmen1 juaruipav pabflomar jaisalmen, marescpla zoiruicha"

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

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

-- "domlloriv"
fun todos2 :: "('a \<Rightarrow> bool) \<Rightarrow> 'a list \<Rightarrow> bool" where
"todos2 p [] = True"
| "todos2 p (x#xs) = ((p x) \<and> todos2 p xs)"

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

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

-- "maresccas4,juaruipav domlloriv pabflomar jaisalmen, marescpla zoiruicha"

lemma "todos (λy. y=x) (copia n x)"
by (induct n) auto

-- "diecabmen1"
lemma "todos (λy. y=x) (copia2 n x)"
by (induct n) auto

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

-- "maresccas4 irealetei diecabmen1 juaruipav domlloriv pabflomar, marescpla"

fun factR :: "nat ⇒ nat" where
"factR 0 = 1"
|"factR (Suc n) = (Suc n) * factR n" <--"creo que no hacen falta los paréntesis del 2º suc (marescpla)"

value "factR 4" -- "= 24"

-- "jaisalmen zoiruicha"
fun factR2 :: "nat ⇒ nat" where
"factR2 0 = 1"
| "factR2 (n) = n * factR2 (n - 1)"

value "factR2 4" -- "= 24"

text {* ---------------------------------------------------------------
Ejercicio 9. Se considera la siguiente definición iterativa de la
función factorial
factI :: "nat ⇒ nat" where
factI n = factI' n 1

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
------------------------------------------------------------------- *}

fun factI' :: "nat ⇒ nat ⇒ nat" where
"factI' 0 x = x"
| "factI' (Suc n) x = factI' n (Suc n)*x"

fun factI :: "nat ⇒ nat" where
"factI n = factI' n 1"

value "factI 4" -- "= 24"

-- "maresccas4 irealetei diecabmen1 juaruipav domlloriv pabflomar jaisalmen, marescpla zoiruicha"

lemma fact: "factI' n x = x * factR n"
by (induct n arbitrary: x) auto

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

-- "maresccas4 diecabmen1 juaruipav pabflomar jaisalmen zoiruicha" "no lo entiendo (marescpla)"

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

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

-- "maresccas4,juaruipav domlloriv jaisalmen zoiruicha"

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

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

-- "irealetei diecabmen1"

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

value "amplia2 [d,a] t" -- "= [d,a,t]"

-- "pabflomar, marescpla" ¿Sería mejor poner los paréntesis en la llamada a amplia como hace maresccas4?
fun amplia3 :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia3 [] y = [y]"
| "amplia3 (x#xs) y = x # amplia3 xs y"

value "amplia3 [d,a] t" -- "= [d,a,t]"

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

-- "maresccas4, juaruipav domlloriv pabflomar jaisalmen zoiruicha"

lemma "amplia xs y = xs @ [y]"
by (induct xs) auto

-- "irealetei diecabmen1" (* Es igual que la de maresccas4, pero lo pego para que compile*)

lemma "amplia2 xs y = xs @ [y]"
by (induct xs) auto

end

</source>

Relación 10

2018-07-16T15:46:12Z

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

<source lang="isabelle">
header {* R10: Deducción natural proposicional *}

theory R10
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es lemas usando sólo las reglas básicas
de deducción natural de la lógica proposicional.

Los ejercicios son los de la asignatura de "Lógica informática" que se
encuentran en http://goo.gl/yrPLn

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

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

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

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

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

--"marescpla, pabflomar, jaisalmen, zoiruicha"

lemma 01:
assumes 1: "p ∨ q"
and 2: "¬q"
shows "p"
using 1
proof (rule disjE)
{assume "p"
then show "p".}
next
{assume "q"
with 2 show "p" by (rule notE)}
qed

--"diecabmen1 maresccas4 domlloriv"
lemma Ejercicio_1:
assumes "p ∨ q"
"¬q"
shows "p"
using assms(1)
proof (rule disjE)
assume "p"
then show "p" .
next
assume "q"
with `¬q` show "p" ..
qed

--"juaruipav, julrobrel"
lemma ej1_juaruipav:
assumes 1:"p ∨ q"
and 2: "¬q"
shows "p"
using 1
proof
assume 3:"p"
then show "p" .
next
assume 4:"q"
show "p" using 2 4 by (rule notE)
qed

--"irealetei, julrobrel"
lemma ej1_auto:
assumes 1:"p ∨ q"
assumes 2:"¬q"
shows "p"
using assms by auto

lemma ej1:
assumes 1:"p ∨ q"
assumes 2:"¬q"
shows "p"
proof -
note 1
moreover
{assume "p"
then have "p" .}
moreover
{assume 3:"q"
have "p" using 2 3 ..}
ultimately show "p" ..
qed

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

--"marescpla, pabflomar,jaisalmen, zoiruicha"

lemma 02:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof (rule ccontr)
assume "¬¬(¬p ∨ ¬q)"
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)
show "False"
using 1
proof (rule disjE)
{assume I: "¬p"
have "p" using assms(1) by (rule conjunct1)
with I show "False"..}
{assume II: "¬q"
have "q" using assms(1) by (rule conjunct2)
with II show "False" ..}
qed
qed

--"diecabmen1 maresccas4 domlloriv"
lemma Ejercicio_2:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume 1: "¬p ∨ ¬q"
show False
using 1
proof (rule disjE)
assume "¬p"
have "p" using assms ..
with `¬p` show False ..
next
assume "¬q"
have "q" using assms ..
with `¬q` show False ..
qed
qed

--"juaruipav"

lemma ej2_juaruipav:
assumes 1:"p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume 2: "¬ p ∨ ¬ q"
show "False"
using 2
proof
assume 3: "¬q"
have 4:"q" using 1 by (rule conjunct2)
show "False" using 3 4 by (rule notE)
next
assume 5: "¬p"
have 6:"p" using 1 by (rule conjunct1)
show "False" using 5 6 by (rule notE)
qed
qed

--"irealetei, julrobrel"
lemma ej2_auto:
assumes 1:"p ∧ q"
shows "¬(¬p ∨ ¬q)"
using assms by auto

lemma ej2:
assumes 1:"p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
moreover
{assume 2:"¬p"
have 3:"p" using 1 ..
have "False" using 2 3 ..}
moreover
{assume 2:"¬q"
have 3:"q" using 1 ..
have "False" using 2 3 ..}
ultimately show "False" ..
qed

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

-- "maresccas4"
lemma
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
{ assume "p"
then have "p ∨ q" ..
with `¬(p ∨ q)` have False ..}
thus "¬p" ..
next
{ assume "q"
then have "p ∨ q" ..
with `¬(p ∨ q)` have False ..}
thus "¬q" ..
qed

-- "diecabmen1 pabflomar domlloriv"
lemma Ejercicio_3:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof -
{ assume "p"
then have "p ∨ q" ..
with assms have False ..}
then have "¬p" ..
{ assume "q"
then have "p ∨ q" ..
with assms have False ..}
then have "¬q" ..
with `¬p` show "¬p ∧ ¬q" ..
qed

--"marescpla,jaisalmen, zoiruicha"
lemma 03:
assumes 1:"¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof (rule ccontr)
{assume "¬¬p"
then have "p" by (rule notnotD)
then have "p ∨ q" by (rule disjI1)
with 1 show "False" ..}
qed
show "¬q"
proof (rule ccontr)
{assume "¬¬q"
then have "q" by (rule notnotD)
then have "p ∨ q" by (rule disjI2)
with 1 show "False" ..}
qed
qed

--"juaruipav"

lemma ej3_juaruipav:
assumes 1: " ¬(p ∨ q)"
shows " ¬p ∧ ¬q"
proof
{assume 2:"p"
have 3: "p∨q" using 2 by (rule disjI1)
have 4: "False" using 1 3 by (rule notE)}
then show "¬p" ..
next
{assume 5:"q"
have 6: "p∨q" using 5 by (rule disjI2)
have 7: "False" using 1 6 by (rule notE)}
then show "¬q" ..
qed

--"irealetei, julrobrel"
lemma ej3_auto:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
using assms by auto

lemma ej3:
assumes 0:"¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
{assume "p"
then have 2:"p ∨ q" ..
have "False" using 0 2 ..}
then show "¬p" ..
next
{assume "q"
then have 2:"p ∨ q" ..
have "False" using 0 2 ..}
then show "¬q" ..
qed

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

-- "maresccas4"
lemma
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
show False
using `p ∨ q`
proof
assume "p"
have "¬p" using `¬p ∧ ¬q` ..
thus False using `p` ..
next
assume "q"
have "¬q" using `¬p ∧ ¬q` ..
thus False using `q` ..
qed
qed

-- "diecabmen1 domlloriv,jaisalmen, zoiruicha"
lemma Ejercicio_4:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
show False
using `p ∨ q`
proof
assume "p"
have "¬p" using assms ..
then show False using `p` ..
next
assume "q"
have "¬q" using assms ..
then show False using `q` ..
qed
qed

--"marescpla"
lemma 04:
assumes 1:"¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule ccontr)
have 2: "¬p" using 1 by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
assume "¬¬(p ∨ q)"
then have 4:"(p ∨ q)" by (rule notnotD)
then show False
proof (rule disjE)
note 4
{assume "p"
with 2 show False ..}
{assume "q"
with 3 show False ..}
qed
qed

-- "pabflomar"

lemma ej4_pfm:
assumes 0:"¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume 1:"p ∨ q"
show False
using 1
proof
assume 1:"p"
have 2: "¬p" using 0 by (rule conjunct1)
then show False using `p` ..
next
assume 1:"q"
have 2: "¬q" using 0 by (rule conjunct2)
then show False using `q` ..
qed
qed

--"juaruipav, julrobrel"
lemma ej4_juaruipav:
assumes 1:" ¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume 2: " p ∨ q"
show "False"
using 2
proof
assume 3:"p"
have 4:"¬p" using 1 by (rule conjunct1)
show "False" using 4 3 by (rule notE)
next
assume 5:"q"
have 6:"¬q" using 1 by (rule conjunct2)
show "False" using 6 5 by (rule notE)
qed
qed

--"irealetei"
lemma ej4_auto:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
using assms by auto

lemma ej4:
assumes 0:"¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
moreover
{assume 1:"p"
have "¬p" using 0 ..
then have "False" using 1 ..}
moreover
{assume 1:"q"
have "¬q" using 0 ..
then have "False" using 1 ..}
ultimately show "False" ..
qed

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

-- "maresccas4 diecabmen1 domlloriv, julrobrel,jaisalmen, zoiruicha"
lemma
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
show False
using `¬p ∨ ¬q`
proof
assume "¬p"
have "p" using `p ∧ q` ..
with `¬p`show False ..
next
assume "¬q"
have "q" using `p ∧ q` ..
with `¬q` show False ..
qed
qed

--"marescpla"

lemma 05:
assumes 1:"¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof (rule ccontr)
assume "¬¬(p ∧ q)"
then have 4:"(p ∧ q)" by (rule notnotD)
have p using 4 by (rule conjunct1)
have q using 4 by (rule conjunct2)
show False
using 1
proof (rule disjE)
{assume "¬p"
then show False using `p` ..}
{assume "¬q"
then show False using `q`..}
qed
qed

-- "pabflomar"
lemma ej5_pfm:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
show False
using `¬p ∨ ¬q`
proof
assume "¬p"
have "p" using `p ∧ q` by (rule conjunct1)
with `¬p` show False by (rule notE)
next
assume "¬q"
have "q" using `p ∧ q` by (rule conjunct2)
with `¬q` show False by (rule notE)
qed
qed

--"juaruipav"
lemma ej5_juaruipav:
assumes 1:"¬p ∨ ¬q"
shows " ¬(p ∧ q)"
using 1
proof
assume 2: "¬p"
show "¬ (p ∧ q)"
proof
assume 3: " p ∧ q"
have 4:"p" using 3 by (rule conjunct1)
show "False " using 2 4 by (rule notE)
qed
next
assume 5: "¬q"
show "¬ (p ∧ q)"
proof
assume 6: " p ∧ q"
have 7:"q" using 6 by (rule conjunct2)
show "False " using 5 7 by (rule notE)
qed

qed

--"irealetei"
lemma ej5_auto:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
using assms by auto

lemma ej5:
assumes 0:"¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume 1:"p ∧ q"
have 2:"p" using 1 ..
have 3:"q" using 1 ..
show "False" using 0
proof
assume "¬p"
then show "False" using 2 ..
next
assume "¬q"
then show "False" using 3 ..
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar
⊢ ((p ⟶ q) ⟶ p) ⟶ p
------------------------------------------------------------------ *}
-- "diecabmen1 maresccas4 pabflomar juaruipav domlloriv,jaisalmen, zoiruicha"
lemma Ejercicio_6:
shows "((p ⟶ q) ⟶ p) ⟶ p"
proof
assume "(p ⟶ q) ⟶ p"
show "p"
proof (rule ccontr)
assume "¬p"
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)
{ assume "p"
with `¬p` have False ..
then have "q" ..}
then have "p ⟶ q" ..
with `¬(p ⟶ q)` show False ..
qed
qed

--"marescpla"

lemma 06:
"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume 1: "((p ⟶ q) ⟶ p)"
show "p"
proof(rule ccontr)
assume "¬p"
with 1 have 2: "¬(p⟶q)" by (rule mt)
then show "False"
proof
{assume "p"
with `¬p` have "q" by (rule notE)}
then show "(p⟶q)" by (rule impI)
qed
qed
qed

--"irealetei, julrobrel"
lemma ej6_auto:"((p ⟶ q) ⟶ p) ⟶ p"
using assms by auto

lemma ej6:"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume 1:"(p ⟶ q)⟶p"
show "p"
proof (rule ccontr)
assume 2:"¬p"
have 4:"¬(p⟶q)" using 1 2 by (rule mt)
{assume 5:"p"
have "False" using 2 5 ..
then have "q" ..}
then have 6:"p⟶q" ..
show "False" using 4 6 ..
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 7. Demostrar
¬q ⟶ ¬p ⊢ p ⟶ q
------------------------------------------------------------------ *}
-- "diecabmen1 pabflomar"
lemma Ejercicio_7:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
{ assume "¬q"
with assms have "¬p" ..
then have False using `p` ..}
then show "q" by (rule ccontr)
qed

--"marescpla,jaisalmen, zoiruicha"
lemma 07:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (rule impI)
{assume 1: "p"
{assume "¬q"
with assms have "¬p" ..
then have "False" using 1 ..}
then have "¬¬q" by (rule notI)
then show "q" by (rule notnotD)}
qed

-- "maresccas4"
lemma
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
then have "¬¬p" by (rule notnotI)
with assms(1) have "¬¬q" by (rule mt)
then show "q" by (rule notnotD)
qed

--"juaruipav, julrobrel, domlloriv"

lemma ej7_juaruipav:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
have 4: "¬¬q" using 1 3 by (rule mt)
show "q" using 4 by (rule notnotD)
qed

--"irealetei"
lemma ej7_auto:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
using assms by auto

lemma ej7:
assumes 0:"¬q ⟶ ¬p"
shows "p ⟶ q"
proof -
{assume 1:"p"
then have 2:"¬¬p" by (rule notnotI)
have "¬¬q" using 0 2 by (rule mt)
then have "q" by (rule notnotD)}
then show "p ⟶ q" ..
qed

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar
¬(¬p ∧ ¬q) ⊢ p ∨ q
------------------------------------------------------------------ *}
-- "diecabmen1"
lemma Ejercicio_8:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
have "¬p ∨ p" ..
{ assume "p"
then have "p ∨ q" ..}
{ assume "¬p"
have "¬q ∨ q" ..
{ assume "q"
then have "p ∨ q" ..}
{ assume "¬q"
with `¬p` have "¬p ∧ ¬q" ..
with assms have False ..
then have "p ∨ q" ..}
with `¬q ∨ q` have "p ∨ q" using `q ⟹ p ∨ q` ..}
with `¬p ∨ p` show "p ∨ q" using `p ⟹ p ∨ q` ..
qed

--"marescpla pabflomar (No se usar otro lema sin usar el simp) maresccas4 (rule 03, en lugar de simp)"
{* Marco lleva razón. GRACIAS!!! *}

lemma 08:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume "¬(p ∨ q)"
then have "¬p ∧ ¬q" by (rule 03)
with assms show "False" ..
qed

--"irealetei, julrobrel"
lemma ej8_auto:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
using assms by auto

lemma ej8:
assumes 0:"¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof -
{assume 1:"¬(p ∨ q)"
have 2:"¬p ∧ ¬q" using 1 by (rule ej3)
have "False" using 0 2 ..}
then show "p ∨ q" by (rule ccontr)
qed

text {* ---------------------------------------------------------------
Ejercicio 9. Demostrar
¬(¬p ∨ ¬q) ⊢ p ∧ q
------------------------------------------------------------------ *}
-- "diecabmen1, maresccas4 domlloriv"
lemma Ejercicio_9:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
{ assume "¬p"
then have "¬p ∨ ¬q" ..
with assms have False ..}
then show "p" by (rule ccontr)
{ assume "¬q"
then have "¬p ∨ ¬q" ..
with assms have False ..}
then show "q" by (rule ccontr)
qed

-- "pabflomar, marescpla"

lemma ej9_pfm:
assumes " ¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have 1: "¬¬p ∧ ¬¬q" using assms by (rule ej3_pfm)
have 2: "¬¬p" using 1 by (rule conjunct1)
have 3: "¬¬q" using 1 by (rule conjunct2)
show "p" using 2 by (rule notnotD)
show "q" using 3 by (rule notnotD)
qed

--"juaruipav"
lemma ej9_juaruipav:
assumes 1: " ¬(¬p ∨ ¬q)"
shows " p ∧ q"
proof
have 2:"(¬¬p)∧(¬¬q)" using 1 by (rule ej3_juaruipav)
have "(¬¬p)" using 2 by (rule conjunct1)
then show "p" by (rule notnotD)
next
have 3:"(¬¬p)∧(¬¬q)" using 1 by (rule ej3_juaruipav)
have "(¬¬q)" using 3 by (rule conjunct2)
then show "q" by (rule notnotD)
qed

--"irealetei, julrobrel"
lemma ej9_auto:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
using assms by auto

lemma ej9:
assumes 0:"¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
{assume "¬p"
then have 1:"¬p ∨ ¬q" ..
have "False" using 0 1 ..}
then show "p" by (rule ccontr)
next
{assume "¬q"
then have 1:"¬p ∨ ¬q" ..
have "False" using 0 1 ..}
then show "q" by (rule ccontr)
qed

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar
¬(p ∧ q) ⊢ ¬p ∨ ¬q
------------------------------------------------------------------ *}
-- "pabflomar, julrobrel, juaruipav, domlloriv"
lemma ej10_pfm:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume 1:"¬ (¬ p ∨ ¬ q)"
show False
proof -
have "p ∧ q" using 1 by (rule ej9_pfm)
with assms show False by (rule notE)
qed
qed

-- "diecabmen1"
lemma Ejercicio_10:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
have "¬p ∨ p" ..
{ assume "p"
have "¬q ∨ q" ..
{ assume "q"
with `p` have "p ∧ q" ..
with assms have False ..
then have "¬p ∨ ¬q" ..}
{ assume "¬q"
then have "¬p ∨ ¬q" ..}
with `¬q ∨ q` have "¬p ∨ ¬q" using `q ⟹ ¬ p ∨ ¬ q` ..}
{ assume "¬p"
then have "¬p ∨ ¬q" ..}
with `¬p ∨ p` show "¬p ∨ ¬q" using ` p ⟹ ¬ p ∨ ¬ q` ..
qed

-- "maresccas4"
lemma a10:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
{ assume "¬p"
then have "¬p ∨ ¬q" ..
with `¬(¬p ∨ ¬q)` have False ..}
hence "¬¬p" ..
thus "p" by (rule notnotD)
{ assume "¬q"
then have "¬p ∨ ¬q" ..
with `¬(¬p ∨ ¬q)` have False ..}
hence "¬¬q" ..
thus "q" by (rule notnotD)
qed

lemma 10:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
then have "p ∧ q" by (rule a10)
with assms(1) show False ..
qed

text {* -----
Ejercicio 9 haciendo uso del Ejercicio 10
----------*}
lemma
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule ccontr)
assume "¬(p ∧ q)"
then have "¬p ∨ ¬q" by (rule 10)
with assms(1) show False ..
qed

--"marescpla"

lemma 10:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
then have 1:"p ∧ q" by (rule 09)
with assms show "False" ..
qed

--"irealetei"
lemma ej10_auto:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
using assms by auto

lemma ej10:
assumes 0:"¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
{assume 1:"¬(¬p ∨ ¬q)"
have 2:"p ∧ q" using 1 by (rule ej9)
have 3:"False" using 0 2 .. }
then show "¬p ∨ ¬q" by (rule ccontr)
qed

text {* ---------------------------------------------------------------
Ejercicio 11. Demostrar
⊢ (p ⟶ q) ∨ (q ⟶ p)
------------------------------------------------------------------ *}
-- "diecabmen1"
lemma Ejercicio_11:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "¬(p ⟶ q) ∨ (p ⟶ q)" ..
{ assume "(p ⟶ q)"
then have "(p ⟶ q) ∨ (q ⟶ p)" ..}
{ assume "¬(p ⟶ q)"
{ assume "q"
{ assume "p"
have "q" using `q` .}
then have "p ⟶ q" ..
with `¬(p ⟶ q)` have False ..
then have "p" ..}
then have "q ⟶ p" ..
then have "(p ⟶ q) ∨ (q ⟶ p)" ..}
with `¬(p ⟶ q) ∨ (p ⟶ q)` show "(p ⟶ q) ∨ (q ⟶ p)" using `p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p)` ..
qed

-- "maresccas4"
lemma
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have 1:"¬(p ⟶ q) ∨ (p ⟶ q)" ..
show "(p ⟶ q) ∨ (q ⟶ p)"
using 1
proof
assume "p ⟶ q"
then show "(p ⟶ q) ∨ (q ⟶ p)" ..
next
{ assume "¬(p ⟶ q)"
{ assume "q"
{ assume "p"
have "q" using `q` .}
then have "p ⟶ q" ..
with `¬(p ⟶ q)` have False ..
then have "p" .. }
then have "q ⟶ p" ..
then show "(p ⟶ q) ∨ (q ⟶ p)" ..}
qed
qed

-- "pabflomar, julrobrel"
{* Sólo cambia respecto de marco en el cambio del . por by this *}
lemma
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have 1:"¬(p ⟶ q) ∨ (p ⟶ q)" ..
show "(p ⟶ q) ∨ (q ⟶ p)"
using 1
proof
assume "p ⟶ q"
then show "(p ⟶ q) ∨ (q ⟶ p)" ..
next
{ assume "¬(p ⟶ q)"
{ assume "q"
{ assume "p"
have "q" using `q` by this
}
then have "p ⟶ q" ..
with `¬(p ⟶ q)` have False ..
then have "p" ..
}
then have "q ⟶ p" ..
then show "(p ⟶ q) ∨ (q ⟶ p)" ..}
qed
qed

-- "irealetei domlloriv juaruipav"

lemma ej11_auto:"(p ⟶ q) ∨ (q ⟶ p)"
using assms by auto

lemma ej11:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof -
have 1:"¬(p ⟶ q) ∨ (p ⟶ q) " by (rule excluded_middle)
then show "(p ⟶ q) ∨ (q ⟶ p)"
proof
note 1
moreover
{assume "p⟶q"
then show "(p ⟶ q) ∨ (q ⟶ p)" ..}
moreover
{assume 2:"¬(p ⟶ q)"
{assume 3:"q"
{assume "p"
have "q" using 3 .}
then have 4:"p⟶q" ..
have "False" using 2 4 ..
then have "p" ..}
then have "q⟶p" ..
then show "(p ⟶ q) ∨ (q ⟶ p)" ..}
qed
qed

end
</source>

Relación 11

2018-07-16T15:46:12Z

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

<source lang="isabelle">
header {* R11: Deducción natural de primer orden *}

theory R11
imports Main
begin

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

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

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

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

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

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

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

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

-- "maresccas4 irealetei" (* Una! nos ha salido Una!!! *)
lemma ej_1_auto:
assumes " P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
using assms by auto

lemma ej_1:
fixes P Q :: "'b ⇒ bool"
assumes 0:"P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
have "¬(P a) ∨ P a" by (rule excluded_middle)
then show "∃x. P a ⟶ Q x"
proof (rule disjE)
{assume 2:"(P a)"
have 4: "∃x. Q x" using 0 2 ..
obtain b where "Q b" using 4 by (rule exE)
then have "P a ⟶ Q b" ..
then show "∃x. P a ⟶ Q x" by (rule exI)}
next
{assume 2:"¬(P a)"
{assume "¬(∃x. P a ⟶ Q x)"
then have 3: "∀x. ¬(P a ⟶ Q x)" by (rule no_ex)
fix b
have "¬(P a ⟶ Q b)" using 3 ..
then have "P a ∧ ¬Q b" by (rule Meson.not_impD)
then have 4:"P a" ..
have "False" using 2 4 ..}
then show " ∃x. P a ⟶ Q x" by (rule ccontr)}
qed
qed

-- "jaisalmen zoiruicha"
lemma implicacion: "⟦P ⟶ Q⟧ ⟹ (¬P ∨ Q)"
by auto

lemma implicacion2: "⟦¬( P ⟶ Q)⟧ ⟹ (P ∧ ¬Q)"
by auto

lemma ej01:
fixes P Q
assumes 0: "P a ⟶ (∃x. Q x)"
assumes 70: "¬(∃x.( P a ⟶ Q x))"
shows "∃x. P a ⟶ Q x"
proof -
have 2: "¬(P a) ∨ (∃x. Q x)" using 0 by (rule implicacion)
then show "∃x. P a ⟶ Q x"
proof (rule disjE)
{assume 1: "(∃x. Q x)"
obtain b where "Q b" using 1 ..
then have "P a ⟶ Q b" ..
then show " ∃x. P a ⟶ Q x" by (rule exI)
}
next
{assume 10: "¬(P a)"
have 50: "∀x. ¬(P a ⟶ Q x)" using 70 by (rule no_ex)
fix b
have "¬( P a ⟶ Q b)" using 50 ..
then have " P a ∧ ¬ Q b" by (rule implicacion2)
then have 20: "P a" ..
have "False" using 10 20 ..
then show " ∃x. P a ⟶ Q x" by (rule ccontr)}
qed
qed

-- "marescpla"
lemma 1:
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof (rule disjE)
show 0: "¬ P a ∨ P a" by (rule excluded_middle)
next
show "¬ P a ⟹(∃ x. P a ⟶ Q x)"
proof-
assume H2: "¬ P a"
then show "∃x. P a ⟶ Q x"
proof-
{assume 1: "P a"
have "Q b" using H2 1 by (rule notE)
hence "Q b" .}
hence "P a ⟶ Q b" ..
hence II: "∃x. P a ⟶ Q x" by (rule exI)
hence "¬ P a ⟶ (∃x. P a ⟶ Q x)" ..
thus "¬ P a ⟹ (∃x. P a ⟶ Q x)" ..
qed
next
qed
assume H1: "P a"
then show "P a ⟹ ∃x. P a ⟶ Q x"
proof-
have "P a" using H1 .
with assms(1) have 2: "∃x. Q x" ..
obtain b where "Q b" using 2 ..
then have H1:"P a ⟶ Q b" ..
then have I: "∃x. P a ⟶ Q x" by (rule exI)
then show "P a ⟹ ∃x. P a ⟶ Q x" .
qed
qed

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

-- "irealetei maresccas4 pabflomar" (* Dos *)

lemma ej_2:
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 -
{fix a
{fix b
{assume 1:"R a b"
have "¬(R b a)"
proof (rule ccontr)
assume "¬¬(R b a)"
then have "R b a" by (rule notnotD)
with 1 have 3:"R a b ∧ R b a" ..
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) ..
then have "∀z. R a b ∧ R b z ⟶ R a z" ..
then have "R a b ∧ R b a ⟶ R a a" ..
then have "R a a" using 3 ..
have "¬(R a a)" using assms(2) ..
then show False using `R a a`..
qed}
then have 4:"R a b ⟶ ¬(R b a)" ..}
then have "∀y. R a y ⟶ ¬ R y a" ..}
then show "∀x y. R x y ⟶ ¬ R y x" ..
qed

-- "marescpla"
lemma 2:
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-
{fix a
have 1: "∀y.∀z. R a y ∧ R y z ⟶ R a z" using assms(1) ..
{fix b
have "∀z. R a b ∧ R b z ⟶ R a z" using 1 ..
hence 2: "R a b ∧ R b a ⟶ R a a" ..
{assume 1: "R a b"
have 3: "¬ R a a" using assms(2) ..
have 4: "¬(R b a) ∨ (R b a)" by (rule excluded_middle)
{assume "R b a"
with 1 have "R a b ∧ R b a" by (rule conjI)
with 2 have "R a a" ..
with 3 have "False" by (rule notE)
then have "¬(R b a)"..}
then have 5: "R b a ⟹ ¬(R b a)"..
{assume "¬(R b a)"
then have "¬(R b a)" .}
with 4 have "¬(R b a)" using 5 ..}
then have 6: "R a b ⟶ ¬(R b a)" ..}
then have "∀y. R a y ⟶ ¬(R y a)" ..}
then show "∀x. ∀y. R x y ⟶ ¬(R y x)" ..
qed

text{*maerscpla: He tenido que alargar un poco más la demostración porque no sé
por qué no me reconocía que "¬(R b a) ∨ (R b a)" y "R b a ⟹ False" ⟹ ¬(R b a)*}

text {* ---------------------------------------------------------------
Ejercicio 3. Demostrar o refutar
(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)
------------------------------------------------------------------ *}
-- "irealetei maresccas4 domlloriv pabflomar jaisalmen zoiruicha marescpla"
lemma ej_3_auto:
assumes "∀x. ∃y. P x y"
shows "∃y. ∀x. P x y"
quickcheck
oops

(*Contra ejemplo
P = (λx. undefined)(a⇣1 := {a⇣2}, a⇣2 := {a⇣1})
*)

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

-- "irealetei maresccas4 domlloriv jaisalmen zoiruicha"
lemma ej_4_auto:
assumes "∃y. ∀x. P x y"
shows "∀x. ∃y. P x y"
using assms by auto

lemma ej_4:
assumes 1:"∃y. ∀x. P x y"
shows "∀x. ∃y. P x y"
proof -
{fix a
obtain b where 2:"∀x. P x b" using 1 ..
have "P a b" using 2 ..
then have "∃y. P a y" ..}
then show "∀x. ∃y. P x y" ..
qed

lemma ej_4_bis:"(∃y. ∀x. P x y) ⟶ (∀x. ∃y. P x y)"
proof
assume 1:"∃y. ∀x. P x y"
{fix a
obtain b where 2:"∀x. P x b" using 1 ..
have "P a b" using 2 ..
then have "∃y. P a y" ..}
then show "∀x. ∃y. P x y" ..
qed

-- "marescpla"
lemma 4:
"(∃y. ∀x. P x y) ⟶ (∀x. ∃y. P x y)"
proof
assume 1: "∃y. ∀x. P x y"
obtain b where 2:" ∀x. P x b" using 1 ..
{fix a
have "P a b" using 2 ..
then have "∃y. P a y" ..}
then show "∀x. ∃y. P x y" ..
qed

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

-- "maresccas4, marescpla: Yo lo tengo sin rallita despues del proof y saltandome el ultimo paso, pero es lo mismo."
-- "jaisalmen zoiruicha"
lemma ej_5:
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) ..
then have "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" ..
then have "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" ..
then have "P (f a) (f a) (f (f a))" using `P a (f a) (f a)` ..
then show "∃z. P (f a) z (f (f a))" ..
qed

-- "irealetei"
lemma ej_5_auto:
assumes "∀x. P a x x"
assumes "∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
using assms by meson

lemma ej_5:
assumes 1:"∀x. P a x x"
assumes 2:"∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
proof -
have 3:"P a (f a) (f a)" using 1 ..
have "∀y z. P a y z ⟶ P (f a) y (f z)" using 2 ..
then have "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" ..
then have 4:" P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" ..
have 5:"P (f a) (f a) (f (f a))" using 4 3 by (rule mp)
then show "∃z. P (f a) z (f (f a))" ..
qed

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

-- "maresccas4, marescpla"
lemma ej_6:
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) ..
then have "Q a (s a) ⟶ Q (s a) (s (s a))" ..
then have "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))" by (rule conjI)
then show "∃z. Q a z ∧ Q z (s (s a))" ..
qed

-- "irealetei"
lemma ej_6_auto:
assumes "∀y. Q a y"
assumes "∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
using assms by meson

lemma ej_6:
assumes 1:"∀y. Q a y"
assumes 2:"∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
proof
have 3:"Q a (s a)" using 1 ..
have "∀y. Q a y ⟶ Q (s a) (s y)" using 2 ..
then have "Q a (s a) ⟶ Q (s a) (s (s a))" ..
then have 4:"Q (s a) (s (s a))" using 3 by (rule mp)
show "Q a (s a) ∧ Q (s a) (s (s a))" using 3 4 by (rule conjI)
qed

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

-- "pabflomar maresccas4 domlloriv zoiruicha jaisalmen"

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

-- "irealetei"
lemma ej_7_auto:
assumes "A ∨ P ⟶ R ∧ F"
assumes "F ∨ N ⟶ Or"
shows "A ⟶ Or"
using assms by auto

lemma ej_7:
assumes 1:"A ∨ P ⟶ R ∧ F"
assumes 2:"F ∨ N ⟶ Or"
shows "A ⟶ Or"
proof
assume "A"
then have 3:"A ∨ P" ..
have "R ∧ F" using 1 3 by (rule mp)
then have "F" ..
then have 4:"F ∨ N" ..
show "Or" using 2 4 by (rule mp)
qed

-- "marescpla"
lemma 7:
assumes "A ∨ P ⟶ R ∧ F "
"(F ∨ N) ⟶ Or "
shows "A ⟶ Or"
proof (rule ccontr)
assume "¬ (A ⟶ Or)"
then have 1:"A ∧ ¬ Or" by simp
then have 2: "¬ Or" ..
have "A"using 1 by (rule conjunct1)
then have "A ∨ P" by (rule disjI1)
with assms(1) have "R ∧ F" by (rule mp)
then have "F" ..
hence "F ∨ N" ..
with assms(2) have "Or" ..
with 2 show "False" ..
qed

text {* ---------------------------------------------------------------
Ejercicio 8. (En APLI2 el ejercicio 5 de LP) Formalizar, y demostrar
la corrección, del siguiente argumento
En cierto experimento, cuando hemos empleado un fármaco A, el
paciente ha mejorado considerablemente en el caso, y sólo en el
caso, en que no se haya empleado también un fármaco B. Además, o se
ha empleado el fármaco A o se ha empleado el fármaco B. En
consecuencia, podemos afirmar que si no hemos empleado el fármaco
B, el paciente ha mejorado considerablemente.
Usar A: Hemos empleado el fármaco A.
B: Hemos empleado el fármaco B.
M: El paciente ha mejorado notablemente.
------------------------------------------------------------------ *}
-- "pabflomar zoiruicha jaisalmen"

lemma ej8_pfm:
assumes "A ⟶ (M ⟷ ¬B)"
"A ∨ B"
shows "¬B ⟶ M"

proof (rule disjE)
show "A ∨ B" using assms(2) by simp
next
{ assume "A"
with assms(1) have "M ⟷ ¬B" by (rule mp)
then show "¬B ⟶ M" using assms by simp}
next
{ assume 1:"B"
{assume 2:"¬B"
then have "M" using 1 by (rule notE)}
then show "¬B ⟶ M" by (rule impI)
}
qed

-- "maresccas4 irealetei domlloriv"
lemma ej_8:
assumes "(A ⟶ M) ⟷ ¬B"
"A ∨ B"
shows "¬B ⟶ M"
using assms(2)
proof
{ assume "A"
{ assume "¬B"
have "¬B ⟶ (A ⟶ M)" using assms(1) ..
then have "A ⟶ M" using `¬B` ..
then have "M" using `A` .. }
then show "¬B ⟶ M" ..
}
next
{ assume "B"
{ assume "¬B"
then have False using `B` ..
then have "M" .. }
then show "¬B ⟶ M" ..
}
qed

-- "marescpla"
lemma 8:
assumes "A ⟶ (M ⟷ ¬B)"
"A ∨ B"
shows "¬B ⟶ M"
proof (rule disjE)
show "A ∨ B" using assms(2) .
next
assume "A"
with assms(1) have 1: "M ⟷ ¬B" by (rule mp)
then show "¬B ⟶ M" ..
next
assume 1:"B"
{assume 2:"¬B"
then have "M" using 1 by (rule notE)}
then show "¬B ⟶ M" by (rule impI)
next
qed

text {* ---------------------------------------------------------------
Ejercicio 9. (En APLI2 el ejercicio 13 de LPO) Formalizar, y decidir
la corrección, del siguiente argumento
Toda persona pobre tiene un padre rico. Por tanto, existe una
persona rica que tiene un abuelo rico.
Usar R(x) para x es rico
p(x) para el padre de x
------------------------------------------------------------------ *}
-- "julrobrel jaisalmen zoiruicha"
lemma apli2_ej13_lpo:
assumes "∀ x. ¬R(x) ⟶ R(p(x))"
shows "∃ x. R(x) ∧ R(p(p(x)))"
using assms
by auto

lemma apli2_ej13_lpo_d:
assumes 0:"∀ x. ¬R(x) ⟶ R(p(x))"
shows "∃ x. R(x) ∧ R(p(p(x)))"
oops

-- "irealetei"
lemma ej_9_auto:
assumes "∀x. ¬R(x)⟶R(p(x))"
shows "∃y. R(y) ⟶ R(p(p(y)))"
using assms by auto

-- "maresccas4"
lemma ej_9:
assumes "∀x. ¬R x ⟶ R (p x)"
shows "∃x. R x ∧ R(p (p x))"
proof -
have "¬(∃x. ¬R(p x)) ∨ (∃x. ¬R(p x))" by (rule excluded_middle)
then show "∃x. R x ∧ R(p (p x))"
proof (rule disjE)
assume "¬(∃x. ¬R(p x))"
then have 1:"∀x. ¬¬R(p x)" by (rule no_ex)
{fix a
have "¬¬R(p a)" using 1 ..
then have "R(p a)" by (rule notnotD)}
then have 2:"∀x. R(p x)" ..
{fix a
have 3:"R(p a)" using 2 ..
have 4:"R(p (p (p a)))" using 2 ..
have "R(p a) ∧ R(p (p (p a)))" using 3 4 ..}
then show "∃x. R x ∧ R(p (p x))" ..
next
assume "∃x. ¬R(p x)"
obtain a where 1:"¬R(p a)" using `∃x. ¬R(p x)` ..
have "¬R(p a) ⟶ R(p (p a))" using assms ..
then have 2:"R(p (p a))" using 1 ..
have "¬R a ⟶ R(p a)" using assms ..
then have "¬¬R a" using 1 by (rule mt)
then have 3:"R a" by (rule notnotD)
then have "R a ∧ R(p (p a))" using 2 by (rule conjI)
then show "∃x. R x ∧ R(p (p x))" ..
qed
qed

-- "marescpla"
lemma 9:
assumes "∀x. ¬ R x ⟶ R(p(x)) "
shows "∃x. R x ∧ R(p(p(x)))"
proof (rule disjE)
fix a
show "¬ R(p(a)) ∨ R(p(a))" by (rule excluded_middle)
next
fix a
have 1:"¬ R a ⟶ R(p(a))" using assms ..
{assume 2: "¬ R(p(a))"
with 1 have "¬ ¬ R a" by (rule mt)
hence 3: "R a" by (rule notnotD)
have "R(p(p(a)))" using assms 2 by simp
with 3 have "R a ∧ R(p(p(a)))" by (rule conjI)
then show "∃x. R x ∧ R(p(p(x)))" by (rule exI)}
next
fix a
{assume "R(p(a))"
then show "∃x. R x ∧ R (p (p x))" using assms by auto}
next
qed

text{* marescpla: Ya he visto y entendido el ejercicio de Marco y se
donde tengo el fallo jeje, pero bueno, yo subo como lo tenía, que es
lo que realmente había hecho por mi misma *}

text {* ---------------------------------------------------------------
Ejercicio 10. (En APLI2 el ejercicio 10 de LPO) Formalizar, y decidir
la corrección, del siguiente argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}
-- "julrobrel"
lemma apli2_ej10_lpo:
assumes "∀ x. Af(x) ⟶ (∀ y. E(y) ⟶ Ap(x,y))"
"∀ y. E(y) ⟶ ¬ Ap(j,y)"
shows "∃ y. E(y) ∧ N(y) ⟶ ¬Af(j)"
using assms
by auto

lemma apli2_ej10_lpo_d:
assumes 0:"∀ x. Af(x) ⟶ (∀ y. E(y) ⟶ Ap(x,y))"
and 1:"∀ y. E(y) ⟶ ¬ Ap(j,y)"
shows "∃ y. E(y) ∧ N(y) ⟶ ¬Af(j)"
oops

-- "irealetei jaisalmen zoiruicha"
lemma ej_10_auto:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x, y)"
assumes "∀y. E(y) ⟶ ¬Ap(j,y)"
shows "∃y. N(y) ∧ E(y) ⟶ ¬Af(j)"
using assms by auto

-- "maresccas4"
lemma ej_10:
assumes "∀x y. (Af(x) ∧ E(y)) ⟶ Ap(x, y)"
" ∀x. E(x) ⟶ ¬Ap(j, x)"
shows "∃x. E(x) ∧ N(x) ⟶ ¬Af(j)"
proof -
{ fix a
{ assume 1:"E(a) ∧ N(a)"
have "¬Af(j)"
proof
assume "Af(j)"
have "E(a)" using 1 ..
have 2:"Af(j) ∧ E(a)" using `Af(j)` `E(a)` ..
have "∀x. Af(j) ∧ E(x) ⟶ Ap(j, x)" using assms(1) ..
then have "Af(j) ∧ E(a) ⟶ Ap(j, a)" ..
then have a:"Ap(j, a)" using 2 ..
have "E(a) ⟶ ¬Ap(j, a)" using assms(2) ..
then have "¬Ap(j, a)" using `E(a)` ..
then show "False" using a ..
qed}
then have "E(a) ∧ N(a) ⟶ ¬Af(j)" ..}
then show "∃x. E(x) ∧ N(x) ⟶ ¬Af(j)" ..
qed
-- pabflomar --

lemma ej10_pfm:
assumes "∀x y. Af(x) ∧ E(y) ⟶ Ap(x,y)"
"∀x. E(x) ⟶ ¬Ap(j,x)"
shows "∀x. E(x) ∧ N(x) ⟶ ¬Af(j)"
using assms by auto

--"maerescpla" --
lemma 10:
assumes "∀x y. (Af(x) ∧ E(y)) ⟶ Ap(x, y)"
" ∀x. E(x) ⟶ ¬Ap(j, x)"
shows "∃x. E(x) ∧ N(x) ⟶ ¬Af(j)"
proof-
{fix a
{assume 1: "E(a) ∧ N(a)"
then have 2: "E(a)" by (rule conjunct1)
have "E(a) ⟶ ¬Ap(j, a)" using assms(2)..
hence 3: "¬Ap(j, a)" using 2 by (rule mp)
have "∀y. (Af(j) ∧ E(y)) ⟶ Ap(j, y)" using assms(1) ..
hence "(Af(j) ∧ E(a)) ⟶ Ap(j, a)" ..
then have "¬(Af(j) ∧ E(a))" using 3 by (rule mt)
hence "¬Af(j) ∨ ¬E(a)" by simp
with 2 have "¬Af(j)" by simp}
then have "E(a) ∧ N(a) ⟹ ¬Af(j)".}
then show "∃x. E(x) ∧ N(x) ⟶ ¬Af(j)" by simp
qed

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

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

-- "julrobrel"
lemma apli2_ej24_lpo_d:
assumes 0:"¬ (∃ x. P(x) ∧ R(x))"
and 1:"∀ x. P(x) ∧ ¬ Q(x) ⟶ R(x)"
shows "P(a) ⟶ Q(a)"
oops

-- "julrobrel: cuatro sencillos lemas, aunque no faciles de demostrar, y al final el principal"

--"julrobrel: es el modus tollens(mt)"
lemma apli2_ej24_lpo_d_aux1:
assumes 0:"p ∧ ¬q ⟶ r"
shows "¬r⟶¬p ∨ q"
using assms
by auto

lemma modus_tollens:
assumes 1:"p ⟶ q"
and 2:"¬q"
shows "¬p"
proof -
{assume 3:"p"
have 4:"q" using 1 3 by (rule mp)
have 5:"False" using 2 4 by (rule notE)}
thus "¬p" ..
qed

lemma modus_tollens2:
assumes 1:"p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{assume 2:"¬q"
have 3:"¬p" using 1 2 by (rule modus_tollens)}
thus 4:"¬q ⟶ ¬p" by (rule impI)
qed

lemma apli2_ej24_lpo_d_aux1_detalle:
assumes 0:"p ∧ ¬q ⟶ r"
shows "¬r⟶¬p ∨ q"
proof -
have 1:"(p ∧ ¬q) ⟶ r" using 0 .
have 2:"¬r ⟶ ¬(p ∧ ¬q)" using 1 by (rule modus_tollens2)
thus 3:"¬r ⟶ ¬p ∨ q" using 2 by auto (* cada vez estan saliendo mas demostraciones. Aqui hay que demostrar ¬(p ∧ ¬q) = ¬p ∨ q *)
qed

-- "julrobrel"
lemma apli2_ej24_lpo_d_aux2:
assumes 0:"¬(p ∧ r)"
shows "p ⟶ ¬r"
using assms
by auto

--"julrobrel: este lema debe de tener un nombre..."
--"julrobrel: ya he encontrado como se llama: Hypothetical Syllogism (HS)"
lemma apli2_ej24_lpo_d_aux3:
assumes "(p ⟶ q) ∧ (q ⟶ r)"
shows "p ⟶ r"
using assms
by auto

--"julrobrel"
lemma apli2_ej24_lpo_d_aux3_detalle:
assumes 0:"(p ⟶ q) ∧ (q ⟶ r)"
shows "p ⟶ r"
proof -
have 1:"p⟶q" using 0 by (rule conjunct1)
have 2:"q⟶r" using 0 by (rule conjunct2)
{assume 3:"p"
have 4:"q" using 1 3 by (rule mp)
have 5:"r" using 2 4 by (rule mp)}
thus 6:"p⟶r" by (rule impI)
qed

-- "julrobrel"
lemma apli2_ej24_lpo_d_aux4:
assumes 0:"p⟶(¬p ∨ q)"
shows "p ⟶ q"
using assms
by auto

-- "julrobrel"
lemma apli2_ej24_lpo_d:
assumes 0:"¬ (∃ x. P(x) ∧ R(x))"
and 1:"∀ x. P(x) ∧ ¬ Q(x) ⟶ R(x)"
shows "P(a)⟶Q(a)"
proof -
have 2:"∀ x. ¬(P(x) ∧ R(x))" using 0 by (rule no_ex)
fix a
have 3:"¬(P(a) ∧ R(a))" using 2 ..
have 4:"P(a) ∧ ¬ Q(a) ⟶ R(a)" using 1 ..
have 5:"¬R(a) ⟶ ¬ P(a) ∨ Q(a)" using 4 by (rule apli2_ej24_lpo_d_aux1)
have 6:"P(a)⟶¬R(a)" using 3 by (rule apli2_ej24_lpo_d_aux2)
have 7:"(P(a)⟶¬R(a)) ∧ (¬R(a) ⟶ ¬P(a) ∨ Q(a))" using 6 5 by (rule conjI)
have 8:"P(a)⟶(¬P(a) ∨ Q(a))" using 7 by (rule apli2_ej24_lpo_d_aux3)
have 9:"P(a)⟶Q(a)" using 8 by (rule apli2_ej24_lpo_d_aux4)
show "P(a)⟶Q(a)" using 9 .
qed

-- "irealetei"
lemma ej_11_auto:
assumes "∀x. P(x) ⟶ ¬R(x)"
assumes "∀y. P(y) ∧ ¬Q(y) ⟶ R(y)"
shows "P(a) ⟶ Q(a)"
using assms by auto

lemma ej_11_irealetei:
assumes 1:"∀x. P(x) ⟶ ¬R(x)"
assumes 2:"∀y. P(y) ∧ ¬Q(y) ⟶ R(y)"
shows "P(a) ⟶ Q(a)"
proof -
{
fix a
assume 3:"P(a)"
have "Q(a)"
proof (rule ccontr)
assume 4:"¬Q(a)"
have 5:"P(a) ∧ ¬Q(a)" using 3 4 ..
have "P(a) ∧ ¬Q(a) ⟶ R(a)" using 2 ..
then have 6:"R(a)" using 5 by (rule mp)
have "P(a) ⟶ ¬R(a)" using 1 ..
then have "¬R(a)" using 3 by (rule mp)
then show "False" using 6 ..
qed}
then show "P (a) ⟶ Q (a)" ..
qed

-- "maresccas4"
lemma ej_11:
assumes "∀x. P(x) ⟶ ¬R(x)"
"∀x. (P(x) ∧ ¬Q(x)) ⟶ R(x)"
shows "P(a) ⟶ Q(a)"
proof -
{assume "P(a)"
have "Q(a)"
proof (rule ccontr)
assume "¬Q(a)"
have 1:"P(a) ∧ ¬Q(a)" using `P(a)` `¬Q(a)` ..
have "P(a) ∧ ¬Q(a) ⟶ R(a)" using assms(2) ..
then have a:"R(a)" using 1 ..
have "P(a) ⟶ ¬R(a)" using assms(1) ..
then have "¬R(a)" using `P(a)` ..
then show "False" using a ..
qed}
then show "P(a) ⟶ Q(a)" ..
qed

-- "marescpla"
lemma 11:
assumes "∀x. P(x) ⟶ ¬R(x)"
"∀x. (P(x) ∧ ¬Q(x)) ⟶ R(x)"
shows "P(a) ⟶ Q(a)"
proof
fix a
assume 1: "P(a)"
have "P(a) ⟶ ¬R(a)" using assms(1)..
hence 2:"¬R(a)" using 1 ..
have "(P(a) ∧ ¬Q(a)) ⟶ R(a)" using assms(2)..
then have "¬(P(a) ∧ ¬Q(a))" using 2 by (rule mt)
then have "¬P(a) ∨ ¬ ¬Q(a)" by simp
then show "Q(a)"
proof
{assume "¬P(a)"
hence "False" using 1 ..
then show "Q(a)" ..}
next
{assume "¬¬Q(a)"
then show "Q(a)" by (rule notnotD)}
next
qed
qed

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

end
</source>

R7

2018-07-16T15:46:11Z

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

<source lang="isabelle">
header {* R7: Recorridos de árboles *}

theory R7
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 t = undefined"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

R8

2018-07-16T15:46:11Z

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

R9

2018-07-16T15:46:11Z

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

Relación 1

2018-07-16T15:46:11Z

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

<source lang="isabelle">

header {* R1: Programación funcional en Isabelle *}

theory R1
imports Main
begin

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

-- "antmacrui maresccas4 diecabmen1 juaruipav marescpla"
fun factorial :: "nat ⇒ nat" where
"factorial 0 = 1"
| "factorial (Suc n) = Suc n * factorial n"

value "factorial 4" -- "24"

-- "irealetei domlloriv"
fun factorial2 :: "nat ⇒ nat" where
"factorial2 (0::nat)= (1::nat)"
| "factorial2 n = n * factorial2 (n - 1)"

value "factorial2 4" -- "24"

-- "julrobrel"
fun factorial3 :: "nat ⇒ nat" where
"factorial3 0 = 1"
| "factorial3 n = factorial3 (n - 1) * n"

value "factorial3 4" -- "24"

-- "jaisalmen zoiruicha"
fun factorial4 :: "nat ⇒ nat" where
"factorial4 0 = 1"
| "factorial4 (n) = n * factorial4 (n- 1)"

value "factorial4 4" -- "24

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

-- "maresccas4 domlloriv"
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0"
| "longitud (x # xs) = Suc (longitud xs)"

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

-- "irealetei pabflomar julrobrel juaruipav"
fun longitud2 :: "'a list ⇒ nat" where
"longitud2 [] = (0::nat)"
| "longitud2 xs = 1 + longitud2 (tl xs) "

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

-- "diecabmen1"
fun longitud3 :: "'a list ⇒ nat" where
"longitud3 [] = 0"
| "longitud3 (head#tail) = 1 + longitud3 tail"

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

-- "marescpla"
fun longitud4 :: "'a list ⇒ nat" where
"longitud4 [] = 0"|
"longitud4 xs = 1 + longitud4 (tl xs) "

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

-- ""jaisalmen zoiruicha"
fun longitud5 :: "'a list ⇒ nat" where
"longitud5 [] = 0"
| "longitud5 (x#a) = 1 + longitud5 a"

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

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

-- "maresccas4 pabflomar"
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia p = (snd p, fst p)"

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

-- "irealetei diecabmen1 domlloriv julrobrel juaruipav marescpla jaisalmen"
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 (x,y) = (y,x)"

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

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

-- "maresccas4 diecabmen1 domlloriv julrobrel juaruipav"
fun inversa :: "'a list ⇒ 'a list" where
"inversa [] = []"
| "inversa (x#xs) = inversa xs @ (x#[])"

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

-- "irealetei pabflomar"
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = [] "
| "inversa2 xs = inversa2 (tl xs) @ (hd xs#[])"

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

-- "jaisalmen zoiruicha"
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (x#a) = inversa3 a @ [x]"

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

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

-- "maresccas4 julrobrel juaruipav marescpla"
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]"

-- "irealetei"
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 (0::nat) x = []"
| "repite2 n x = x#(repite2 (n - 1) x) "

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

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

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

-- "domlloriv pabflomar jaisalmen zoiruicha"
fun repite4 :: "nat ⇒ 'a ⇒ 'a list" where
"repite4 0 x = []"
| "repite4 n x = x# repite4 (n - 1) x"

value "repite4 3 a" -- "= [a,a,a]"

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

-- "maresccas4 julrobrel"
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]"

-- irealetei
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 xs [] = xs"
| "conc2 xs ys = hd ys # conc2 xs (tl ys)"

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

-- "diecabmen1 domlloriv pabflomar juaruipav"
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 xs ys = xs@ys"

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

-- "marescpla"
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 [] [] = []"|
"conc4 [] ys = (hd ys) # conc4 [] (tl ys)"|
"conc4 xs ys = (hd xs) # conc4 (tl xs) ys"

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

-- "jaisalmen zoiruicha"
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] ys = ys"
| "conc5 xs [] = xs"
| "conc5 (x#xs) ys = x # conc5 xs ys"

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

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

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

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

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

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

-- "julrobrel,juaruipav"
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []"
|"coge4 (Suc n) [] = []"
|"coge4 (Suc n) (x#xs) = x # (coge4 n xs)"

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

-- "marescpla"
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 0 xs = []"|
"coge5 (Suc n) xs = hd xs # coge5 n (tl xs)"

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

-- "jaisalmen zoiruicha"
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 0 xs = []"
| "coge6 n [] = []"
| "coge6 n (x#xs) = x # (coge6 (n-(1::nat)) xs)"

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

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

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

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

-- "irealetei pabflomar"
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
" elimina2 0 xs = xs "
| "elimina2 n xs = elimina2 (n - 1) (tl xs)"

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

-- "diecabmen1"
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs"
| "elimina3 n [] = []"
| "elimina3 n (x#xs) = elimina3 (n - 1) xs"

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

-- "julrobrel, juaruipav"
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 0 xs = xs"
|"elimina4 (Suc n) [] = []"
|"elimina4 (Suc n) (x#xs) = (elimina4 n xs)"

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

-- "marescpla"
fun elimina5 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina5 0 xs = xs"|
"elimina5 (Suc n) xs = elimina5 n (tl xs)"

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

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

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

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

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

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

-- "irealetei domlloriv pabflomar julrobrel juaruipav marescpla"
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 [] = True"|
"esVacia2 xs = False"

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

-- "diecabmen1"
fun esVacia3 :: "'a list ⇒ bool" where
"esVacia3 xs = (if xs = [] then True else False)"

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

-- "jaisalmen zoiruicha"
fun esVacia4 :: "'a list ⇒ bool" where
"esVacia4 x = (if longitud(x)=0 then True else False)"

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

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

-- "maresccas4 domlloriv"
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 "inversaAc2 [a,c,b,e]" -- "= [e,b,c,a]"

-- "irealetei"
fun inversaAc2Aux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAc2Aux xs [] = xs"
| "inversaAc2Aux xs ys = inversaAc2Aux ((hd ys) # xs) (tl ys)"

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

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

-- "diecabmen1 julrobrel,juaruipav"
fun inversaAc3Aux :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAc3Aux xs ys = xs@ys"

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

value "inversaAc3 [a,c,b,e]" -- "= [e,b,c,a]"
-- "pabflomar"
fun inversaAcAux4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux4 [] ys = ys"
| "inversaAcAux4 xs ys = inversaAcAux4 (tl xs) ((hd xs) # ys)"

fun inversaAc4 :: "'a list ⇒ 'a list" where
"inversaAc4 xs = inversaAcAux4 xs []"

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

-- "marescpla"
fun inversaAcAux5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux5 [] ys = ys"|
"inversaAcAux5 xs ys = inversaAcAux5 (elimina 1 xs) (conc (coge 1 xs) ys)"

fun inversaAc5 :: "'a list ⇒ 'a list" where
"inversaAc5 xs = inversaAcAux5 xs []"

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

-- "jaisalmen"
fun inverseAcAux6 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inverseAcAux6 xs ys = xs@ys"

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

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

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

-- "maresccas4 diecabmen1 domlloriv julrobrel juaruipav jaisalmen zoiruicha"
fun sum :: "nat list ⇒ nat" where
"sum [] = 0"
| "sum (x#xs) = x + sum xs"

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

-- "irealetei pabflomar marescpla"
fun sum2 :: "nat list ⇒ nat" where
"sum2 [] = 0"
|"sum2 xs = hd xs + sum2 (tl xs)"

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

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

-- "maresccas4 domlloriv julrobrel juaruipav"
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]"

-- "irealetei pabflomar"
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []"
|"map2 f xs = f(hd xs) # map2 f (tl xs)"

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

-- "diecabmen1"
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []"
| "map3 f (x#xs) = ((f x)#[]) @ (map3 f xs)"

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

-- "marescpla"
fun map4 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map4 f [] = []"|
"map4 f xs = value f (coge 1 xs) # map4 f (elimina 1 xs)"

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

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

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

end
</source>

R4

2018-07-16T15:46:10Z

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

R5

2018-07-16T15:46:10Z

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

R6

2018-07-16T15:46:10Z

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

R11

2018-07-16T15:46:09Z

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

R12

2018-07-16T15:46:09Z

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

R2

2018-07-16T15:46:09Z

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

R3

2018-07-16T15:46:09Z

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

Documentación

2018-07-16T15:46:08Z

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

En esta página se recogen en enlaces que sirven de documentación al curso de demostración asistida por ordenador (DAO).

== Visiones generales de la DAO ==

# J.A. Alonso. [http://goo.gl/NWk7b Razonamiento formalizado: Del sueño a la realidad de las pruebas]. ''Vestigium'', 26 de diciembre de 2012.
# J. Avigad. [http://www.andrew.cmu.edu/user/avigad/Talks/icerm.pdf Interactive theorem proving, automated reasoning, and mathematical computation]. ICERM, 14 de diciembre de 2012.
# M. Davis. [http://www.cs.nyu.edu/cs/faculty/davism/early.ps The early history of automated deduction].
# J.P. Delahaye [http://interstices.info/jcms/int_63417/du-reve-a-la-realite-des-preuves Du rêve à la réalité des preuves]. ''Interstices'', 8 de julio de 2012.
# J. Germoni [http://images.math.cnrs.fr/Coq-et-caracteres.html Coq et caractères: Preuve formelle du théorème de Feit et Thompson]. ''Images des Mathématiques'', CNRS, 23 de noviembre de 2012.
# H. Geuvers [http://www.ias.ac.in/sadhana/Pdf2009Feb/3.pdf Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://www.cs.ru.nl/~freek/pubs/qed2.ps.gz The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/prog-prove.pdf Programming and proving in Isabelle/HOL]. 5 de diciembre de 2013.
# T. Nipkow, M. Wenzel y L.C. Paulson [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/tutorial.pdf A proof assistant for higher-order logic]. Springer-Verlag. 5 de diciembre de 2013.
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/library/HOL/HOL/document.pdf Isabelle/HOL — Higher-Order Logic]. 5 de diciembre de 2013.
# M. Wenzel [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/isabelle-ref.pdf The Isabelle/Isar Reference Manual]. 5 de diciembre de 2013.
# M. Wenzel [https://www.lri.fr/~wenzel/Isabelle2011-Paris/quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle2013].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/i1m/temas/2012-13-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# J.A. Alonso y M.J. Hidalgo [http://www.cs.us.es/~jalonso/publicaciones/Piensa_en_Haskell.pdf Piensa en Haskell (Ejercicios de programación funcional con Haskell)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# G. Hutton [http://goo.gl/pKqG Programming in Haskell]. Cambridge University Press, 2007.
# M. Lipovača [http://aprendehaskell.es ¡Aprende Haskell por el bien de todos!].

=== Lógica computacional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/temas/temas-LI-2012-13.pdf Temas de "Lógica informática" (2012-13)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# R. Bornat [http://bit.ly/oithic Proof and disproof in formal logic: an introduction for programmers]. Oxford University Press, 2005.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://goo.gl/TMqOo Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# A.D. Brucker, D. Basin, J.G. Smaus y B. Wolff. [http://archiv.infsec.ethz.ch/education/permanent/csmr.html Computer-supported Modeling and Reasoning]. (ETH Zurich, 2011).
# Mads Dam. [http://www.csc.kth.se/utbildning/kth/kurser/DD2453/aform07/ Advanced formal methods]. (KTH Royal Institute of Technology, 2007).
# Jacques Fleuriot y Paul Jackson. [http://www.inf.ed.ac.uk/teaching/courses/ar/slides/ Automated reasoning]. (Univ. de Edimburgo, 2012-13).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www4.informatik.tu-muenchen.de/~nipkow/semantics/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/Homepage/SVHOL10 Specification and Verification with Higher-Order Logic].
# Viorel Preoteasa, Ralph-Johan Back y Charmi Panchal. [http://users.abo.fi/vpreotea/isabelle-2012 Introduction to mechanized reasoning with Isabelle/HOL]. (Åbo Akademi University, 2012).
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Yves Bertot, Pierre Casteran, Benjamin Gregoire, Pierre Letouzey y Assia Mahboubi [http://www.di.ens.fr/~zappa/teaching/coq/ecole11 Modelling and verifying algorithms in Coq: an introduction]. (INRIA Paris-Rocquencourt, 14-18 noviembre 2011).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Nuno Gaspar [http://www-sop.inria.fr/members/Nuno.Gaspar/teaching/coq2012.php Verification with the Coq Proof Assistant] (INRIA Sophia Antipolis, 2012-13).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# Michael Genesereth [http://logic.stanford.edu/classes/cs157/2011/cs157.html Computational Logic] (Univ. de Stanford, 2011-12).
# Ian Hodkinson [http://www.doc.ic.ac.uk/~imh/teaching/140_logic/logic.html Logic] (Imperial College, Londres, 2010-11).
# Peter Lucas [http://www.cs.ru.nl/~peterl/teaching/KeR/ Knowledge Representation and Reasoning] (Radboud University # egen, 2011-12).
# Larry Paulson [http://www.cl.cam.ac.uk/Teaching/current/LogicProof/ Logic and Proof] (Univ. de Cambridge, 2011-12).
# Michael Winter [Logic in Computer Science] (Brock University, Ontario, Canada, 2010-11).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://www.cs.nott.ac.uk/~lad/research/challenges/ Induction Challenge Problems].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==
Están en orden cronológico inverso a la fecha de su reseña en [http://www.glc.us.es/~jalonso/vestigium/tag/resena Vestigium]:
# [http://bit.ly/1iZjgqN Proof Pearl: A probabilistic proof for the Girth-Chromatic number theorem]. L. Noschinski
# [http://bit.ly/1iJ8uVz A graph library for Isabelle]. ~ L. Noschinski
# [http://bit.ly/I0CU80 Gödel’s incompleteness theorems]. ~ L.C. Paulson
# [http://bit.ly/I0CPRN The hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/HBiIJI Applications of real number theorem proving in PVS]. ~ H. Gottliebsen, R. Hardy, O. Lightfoot y U. Martin
# [http://bit.ly/1awnMLB A machine-assisted proof of Gödel’s incompleteness theorems for the theory of hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/19lWeYy Verified AIG algorithms in ACL2]. ~ J. Davis y S. Swords
# [http://bit.ly/GAhC00 A formal model and correctness proof for an access control policy framework]. ~ C. Wu, X. Zhang y C. Urban
# [http://bit.ly/16SMvSS The ontological argument in PVS]. ~ J. Rushby
# [http://bit.ly/1dRt9n0 Formalizing Moessner’s theorem and generalizations in Nuprl]. ~ M. Bickford, D. Kozen y A. Silva
# [http://bit.ly/1bSeDNB Formalization in PVS of balancing properties necessary for the security of the Dolev-Yao cascade protocol model]. ~ M. Ayala y Y. Santos
# [http://bit.ly/1feFqWE Proof assistant based on didactic considerations]. ~ J. Pais y A Tasistro
# [http://bit.ly/18tHNBi Theory exploration for interactive theorem proving]. ~ M. Johansson
# [http://bit.ly/1b0242s From Tarski to Hilbert]. ~ G. Braun y J. Narboux
# [http://bit.ly/18HaXaR Formal verification of language-based concurrent noninterference]. ~ A. Popescu, J. Hölzl y T. Nipkow
# [http://bit.ly/1aRTQsU A Traffic Alert and Collision Avoidance System(TCAS-II) Resolution Advisory Algorithm]. ~ C. Muñoz, A. Narkawicz y J. Chamberlain
# [http://bit.ly/1dNwhDI Formal verification of cryptographic security proofs]. ~ M. Berg
# [http://bit.ly/17muAUv Polygonal numbers in Mizar]. ~ A. Grabowski
# [http://bit.ly/1hk5z6L A mechanised proof of Gödel’s incompleteness theorems using Nominal Isabelle]. ~ L.C. Paulson
# [http://bit.ly/1cSL0wE Steps towards verified implementations of HOL Light]. ~ M.O. Myreen, S. Owens y R. Kumar
# [http://bit.ly/16Kbgm0 Generic datatypes à la carte]. ~ S. Keuchel y T. Schrijvers
# [http://bit.ly/1bqJGx4 Proof pearl: A verified bignum implementation in x86-64 machine code]. ~ M.O. Myreen y G. Curello
# [http://bit.ly/142ow2Q Mechanized metatheory for a λ λ-calculus with trust types]. ~ R. Ribeiro, C. Camarão y L. Figueiredo
# [http://bit.ly/15WZBDy Proving soundness of combinatorial Vickrey auctions and generating verified executable code]. ~ M.B. Caminati, M. Kerber, C. Lange y C. Rowat
# [http://bit.ly/198g4n9 A computer-assisted proof of correctness of a marching cubes algorithm]. ~ A.N. Chernikov y J. Xu
# [http://bit.ly/11QA5g7 Verifying the bridge between simplicial topology and algebra: the Eilenberg-Zilber algorithm]. ~ L. Lambán, J. Rubio, F.J. Martín y J.L. Ruiz
# [http://bit.ly/1cJAXYk The Königsberg bridge problem and the friendship theorem]. ~ W. Li
# [http://bit.ly/13DBK9R Formal verification of a proof procedure for the description logic ALC]. ~ M. Chaabani, M. Mezghiche y M. Strecker
# [http://bit.ly/1ep2ex9 Pratt’s primality certificates]. ~ S. Wimmer y L. Noschinski
# [http://bit.ly/13C95Ci Reasoning about higher-order relational specifications]. ~ Y. Wang, K. Chaudhuri, A. Gacek y G. Nadathur
# [http://bit.ly/18QQLcL Proofs you can believe in – Proving equivalences between Prolog semantics in Coq]. ~ J. Kriener, A. King y S. Blazy
# [http://bit.ly/19uc82J Certified, efficient and sharp univariate Taylor models in Coq]. ~ E. Martin-Dorel, L. Rideau, L. Théry, M. Mayero y I. Paşca
# [http://bit.ly/1c4Rzel Ordinals in HOL: Transfinite arithmetic up to (and beyond) ω₁]. ~ M. Norrish y B. Huffman
# [http://bit.ly/14b4Akz Program verification based on Kleene algebra in Isabelle/HOL] ~ A. Armstrong, G. Struth y T. Weber
# [http://bit.ly/1aOgRKx Reading an algebra textbook (by translating it to a formal document in the Isabelle/Isar language)]. ~ C. Ballarin
# [http://bit.ly/11HKixj Computational verification of network programs in Coq]. ~ G. Stewart
# [http://www.glc.us.es/~jalonso/vestigium/resena-certifying-homological-algorithms-to-study-biomedical-images Certifying homological algorithms to study biomedical images]. ~ M. Poza
# [http://bit.ly/16Nks9m Formalizing cut elimination of coalgebraic logics in Coq]. ~ H. Tews
# [http://www.glc.us.es/~jalonso/vestigium/resena-the-formalization-of-syntax-based-mathematical-algorithms-using-quotation-and-evaluation/ The formalization of syntax-based mathematical algorithms using quotation and evaluation]. ~ W.M. Farmer
# [http://www.glc.us.es/~jalonso/vestigium/resena-certified-symbolic-manipulation-bivariate-simplicial-polynomials/ Certified symbolic manipulation: Bivariate simplicial polynomials]. ~ L. Lambán, F.J. Martín, J. Rubio y J.L. Ruiz
# [http://www.glc.us.es/~jalonso/vestigium/resena-solveurs-cpfd-verifies-formellement/ Solveurs CP(FD) vérifiés formellement]. ~ C Dubois y A. Gotlieb
# [http://www.glc.us.es/~jalonso/vestigium/resena-formalizing-bounded-increase/ Formalizing bounded increase]. ~ R. Thiemann
# [http://www.glc.us.es/~jalonso/vestigium/resena-formal-mathematics-on-display-a-wiki-for-flyspeck/ Formal mathematics on display: A wiki for Flyspeck]. ~ C. Tankink, C. Kaliszyk, J. Urban y H. Geuvers
# [http://www.glc.us.es/~jalonso/vestigium/resena-theorem-of-three-circles-in-coq Theorem of three circles in Coq]. ~ J. Zsidó
# [http://bit.ly/19fiWAY Certified HLints with Isabelle/HOLCF-Prelude]. ~ J. Breitner, B. Huffman, N. Mitchell y C. Sternagel
# [http://bit.ly/ZfSQrQ Automatic data refinement]. ~ P. Lammich
# [http://bit.ly/18vyjm7 The rooster and the butterflies (a machine-checked proof of the Jordan-Hölder theorem for finite groups)]. ~ A. Mahboubi
# [http://bit.ly/114oyZV Mechanical verification of SAT refutations with extended resolution]. ~ N. Wetzler, M.J.H. Heule y W.A. Hunt Jr.
# [http://bit.ly/13H0REu Type classes and filters for mathematical analysis in Isabelle/HOL] ~ J. Hölzl, F. Immler y B. Huffman
# [http://bit.ly/10fv8wO Verifying refutations with extended resolution]. ~ M. J. H. Heule, W. A. Hunt, Jr. y N. Wetzler
# [http://bit.ly/10EcFWj A Web interface for Isabelle: The next generation]. ~ C. Lüth y M. Ring
# [http://bit.ly/18P9CSv On the formalization of continuous-time Markov chains in HOL]. ~ L. Liu, O. Hasan y S. Tahar
# [http://bit.ly/17H2mqy Formalizing Turing machines]. ~ A. Asperti y W. Ricciotti
# [http://bit.ly/YwuCeL Light-weight containers for Isabelle: efficient, extensible, nestable]. ~ A. Lochbihler
# [http://bit.ly/10XLrRA Graph theory]. ~ L. Noschinski
# [http://bit.ly/19kPEP4 A machine-checked proof of the odd order theorem]. ~ G. Gonthier et als.
# [http://goo.gl/LdihL A constructive theory of regular languages in Coq]. ~ C. Doczkal, J.O. Kaiser y G. Smolka
# [http://goo.gl/gwcwL A formal proof of Kruskal’s tree theorem in Isabelle/HOL]. ~ C. Sternagel
# [http://goo.gl/CUF3e Formalizing Knuth-Bendix orders and Knuth-Bendix completion]. ~ C. Sternagel y R. Thiemann
# [http://goo.gl/9JAfX Developing an auction theory toolbox]. ~ C. Lange, C. Rowat, W. Windsteiger y M. Kerber
# [http://goo.gl/6OfmQ Formalization of incremental simplex algorithm by stepwise refinement]. ~ M. Spasić y F. Marić
# [http://goo.gl/Guxky Coinductive pearl: Modular first-order logic completeness]. ~ J.C. Blanchette, A. Popescu y D. Traytel
# [http://goo.gl/HUOl8 A fully verified executable LTL model checker]. ~ J. Esparza et als.
# [http://goo.gl/RV54S ForMaRE - formal mathematical reasoning in economics]. ~ M. Kerber, C. Lange y C. Rowat.
# [http://goo.gl/Y7sIq AI over large formal knowledge bases: The first decade]. ~ J. Urban.
# [http://goo.gl/vvqNg Formalization of real analysis: A survey of proof assistants and libraries]. ~ S. Boldo, C. Lelay y G. Melquiond.
# [http://goo.gl/bEFYa Data refinement in Isabelle/HOL]. ~ F. Haftmann, A. Krauss, O. Kunčar y T. Nipkow
# [http://goo.gl/xTyvE Formalizing the confluence of orthogonal rewriting systems]. ~ A.C. Rocha y M. Ayala.
# [http://goo.gl/zCYHj Formalization of the complex number theory in HOL4]. ~ Z. Shi et als.
# [http://goo.gl/kM0dI Programming and reasonning with PowerLists in Coq]. ~ F. Loulergue y V. Niculescu
# [http://goo.gl/KkU6s A hierarchy of mathematical structures in ACL2]. ~ J. Heras, F.J. Martín y V. Pascual.
# [http://www.inf.kcl.ac.uk/staff/urbanc/Publications/tm.pdf Mechanising Turing Machines and Computability Theory in Isabelle/HOL] ~ J. Xu, X. Zhang y C. Urban

R1

2018-07-16T15:46:08Z

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

R10

2018-07-16T15:46:08Z

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

Temas

2018-07-16T15:45:17Z

WikiSysop:

* [[Tema 1: Programación funcional en Isabelle]].
* [http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8t.pdf Tema 2a: Razonamiento sobre programas Haskell]
* [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5a: Verificación de la ordenación por inserción]].
* [[Tema 5b: Verificación de la ordenación por mezcla]].
* [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 6a: Deducción natural proposicional]].
* [[Tema 6b: Deducción natural proposicional con Isabelle/HOL]].
* [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 7a: Deducción natural en lógica de primer orden]].
* [[Tema 7b: Deducción natural en lógica de primer orden con Isabelle/HOL]].
* [[Tema 8: Caso de estudio: Compilación de expresiones]].
* [http://www.cs.us.es/~jalonso/cursos/dao-12/temas/tema-1.pdf Tema 9: Panorama de la demostración asistida por ordenador].

MediaWiki:Common.css

2018-07-16T15:44:52Z

WikiSysop: Página creada con «/* Los estilos CSS colocados aquí se aplicarán a todas las apariencias */ @import url("/~jalonso/font-awesome-4.7.0/css/font-awesome.min.css");»

/* Los estilos CSS colocados aquí se aplicarán a todas las apariencias */
@import url("/~jalonso/font-awesome-4.7.0/css/font-awesome.min.css");

Razonamiento automático (2013-14)

2013-10-23T15:48:21Z

WikiSysop: Protegió «Razonamiento automático (2013-14)» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

== Relaciones de ejercicios ==

=== Relaciones de ejercicios corregidos ===

En esta sección se encuentran las relaciones de ejercicios corregidos en las clases.

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.
* '''Relación 1''': Representación del conocimiento proposicional. ([[R1 |Enunciado]] y [[Relación 1 |Solución colaborativa]]).

Razonamiento automático (2013-14)

2013-10-23T15:46:00Z

WikiSysop: /* Relaciones de ejercicios propuestos */

Razonamiento automático (2013-14)

2013-10-23T15:42:57Z

WikiSysop: /* Relaciones de ejercicios propuestos */

== Relaciones de ejercicios ==

=== Relaciones de ejercicios corregidos ===

En esta sección se encuentran las relaciones de ejercicios corregidos en las clases.

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.
* '''Relación 1''': Representación del conocimiento proposicional. ([[Media:R1.thy |Enunciado]] y [[Relación 1 |Solución colaborativa]]).

MediaWiki:Sidebar

2013-10-22T15:29:01Z

WikiSysop: Página creada con '* navigation ** mainpage|mainpage-description ** recentchanges-url|recentchanges * SEARCH * TOOLBOX * LANGUAGES'

* navigation
** mainpage|mainpage-description
** recentchanges-url|recentchanges
* SEARCH
* TOOLBOX
* LANGUAGES

Razonamiento automático (2013-14)

2013-10-22T15:28:19Z

WikiSysop: Página creada con '== Relaciones de ejercicios == === Relaciones de ejercicios corregidos === En esta sección se encuentran las relaciones de ejercicios corregidos en las clases. === Relacione...'

MediaWiki:Mainpage

2013-10-22T15:26:51Z

WikiSysop: Página creada con 'Razonamiento automático (2013-14)'

Razonamiento automático (2013-14)