Demostración asistida por ordenador (2011-12) - Contribuciones del usuario [es]

DAO2011 (Demostración asistida por ordenador)

2018-07-15T18:19:58Z

Jalonso:

Este curso es una introducción a la demostración asistida por ordenador usando el sistema [http://www.cl.cam.ac.uk/research/hvg/Isabelle Isabelle/HOL/Isar]). Los objetivos del curso son:
* desarrollar la capacidad de razonamiento lógico,
* conocer formalismos de representación del conocimiento matemático,
* saber usar sistemas de razonamiento y
* desarrollar teorías matemáticas en sistemas de demostración automática.

Administrativamente, es un [http://www.cfp.us.es/web/ficha_avanzada.asp?id_titulo=846&tipo=FE&basica=1&curso=2010 curso de formación especializada] del [http://www.cfp.us.es/ Centro de Formación Permanente de la Universidad de Sevilla].

== Material para el curso ==
* [[Temas]]: Teorías de los temas.
* [[Ejercicios]]: Relaciones de ejercicios.
* [http://www.cs.us.es/~jalonso/cursos/dao/doc.html Documentación]: Enlaces con documentación.
* [http://www.cs.us.es/~jalonso/cursos/dao/sistemas.html Sistemas]: Sistemas utilizados.
* [http://www.glc.us.es/~jalonso/vestigium/tag/dao2011/ Diario]: Descripción diaria de las clases.

== Razonamiento automático (2011-12) ==
* [[Tema 6: Isabelle como un lenguaje funcional]].
* [[Tema 7: El lenguaje de demostración Isar]].
* [[Tema 8: Distinción de casos e inducción]].
* [[Tema 9: Patrones de demostración]].
* [[Tema 10: Heurísticas para la inducción y recursión general]].
* [[Tema 11: Caso de estudio: Compilación de expresiones]].
* [[Tema 12: Conjuntos, funciones y relaciones]].

Tema 4 ej

2018-07-15T18:18:38Z

Jalonso:

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

section {* Deducción natural de primer orden *}

text {* Los ejercicios de esta relación deben de resolverse usando sólo
las reglas básicas de la deducción natural proposicional y de primer
orden:
· 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
· 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
*}

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

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

lemma ejercicio_1:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. P x) ⟶ (∀x. Q x)"
oops

lemma ejercicio_2:
assumes "∃x. ¬P x"
shows " ¬(∀x. P x)"
oops

lemma ejercicio_3:
assumes "∀x. P x"
shows "∀y. P y"
oops

lemma ejercicio_4:
assumes "∀x. P x ⟶ Q x"
shows "(∀x. ¬Q x) ⟶ (∀x. ¬P x)"
oops

lemma ejercicio_5:
assumes "∀x. P x ⟶ ¬Q x"
shows "¬(∃x. P x ∧ Q x)"
oops

lemma ejercicio_6:
assumes "∀x. ∀y. P x y"
shows "∀u. ∀v. P u v"
oops

lemma ejercicio_7:
assumes "∃x. ∃y. P x y"
shows "∃u. ∃v. P u v"
oops

lemma ejercicio_8:
assumes "∃x. ∀y. P x y"
shows "∀y. ∃x. P x y"
oops

lemma ejercicio_9:
assumes "∃x. P a ⟶ Q x"
shows "P a ⟶ (∃x. Q x)"
oops

lemma ejercicio_10:
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
oops

lemma ejercicio_11:
assumes "(∃x. P x) ⟶ Q a"
shows "∀x. P x ⟶ Q a"
oops

lemma ejercicio_12:
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
oops

lemma ejercicio_13:
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
oops

lemma ejercicio_14:
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
oops

lemma ejercicio_15:
assumes "∀x.∀y. P y ⟶ Q x"
shows "(∃y. P y) ⟶ (∀x. Q x)"
oops

lemma ejercicio_16:
assumes "¬(∀x. ¬P x)"
shows "∃x. P x"
oops

lemma ejercicio_17:
assumes "∀x. ¬P x"
shows "¬(∃x. P x)"
oops

lemma ejercicio_18:
assumes "∃x. P x"
shows "¬(∀x. ¬P x)"
oops

lemma ejercicio_19:
assumes "P a ⟶ (∀x. Q x)"
shows "∀x. P a ⟶ Q x"
oops

lemma ejercicio_20:
assumes "∀x.∀y.∀z. R x y ∧ R y z ⟶ R x z" and
"∀x. ¬R x x"
shows "∀x.∀y. R x y ⟶ ¬R y x"
oops

lemma ejercicio_21:
assumes "∀x. P x ∨ Q x" and
"∃x. ¬Q x" and
"∀x. R x ⟶ ¬P x"
shows "∃x. ¬R x"
oops

lemma ejercicio_22:
assumes "∀x. P x ⟶ Q x ∨ R x" and
"¬(∃x. P x ∧ R x)"
shows "∀x. P x ⟶ Q x"
oops

lemma ejercicio_23:
assumes "∃x.∃y. R x y ∨ R y x"
shows "∃x.∃y. R x y"
oops

end
</source>

Tema 3 ej

2018-07-15T18:18:20Z

Jalonso:

<source lang="isabelle">
header {* Deducción natural proposicional *}

theory Tema_3_ej
imports Main
begin

text {* Los ejercicios de esta relación deben de resolverse usando sólo
las reglas básicas de la deducción natural proposicional:
· 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
*}

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

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

lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
oops

lemma ejercicio_2:
assumes 1: "p⟶q" and
2: "q⟶r" and
3: "p"
shows "r"
oops

lemma ejercicio_3:
assumes 1: "p⟶(q⟶r)" and
2: "p⟶q" and
3: "p"
shows "r"
oops

lemma ejercicio_4:
assumes 1: "p⟶q" and
2: "q⟶r"
shows "p⟶r"
oops

lemma ejercicio_5:
"p⟶(q⟶r) ⟹ q⟶(p⟶r)"
oops

lemma ejercicio_6:
"p⟶(q⟶r) ⟹ (p⟶q)⟶(p⟶r)"
oops

lemma ejercicio_7:
"p ⟹ q⟶p"
oops

lemma ejercicio_8:
"p⟶(q⟶p)"
oops

lemma ejercicio_9:
"p⟶q ⟹ (q⟶r)⟶(p⟶r)"
oops

lemma ejercicio_10:
"p⟶(q⟶(r⟶s)) ⟹ r⟶(q⟶(p⟶s))"
oops

lemma ejercicio_11:
"(p⟶(q⟶r))⟶((p⟶q)⟶(p⟶r))"
oops

lemma ejercicio_12:
"(p⟶q)⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_13:
"⟦p; q⟧ ⟹ p∧q"
oops

lemma ejercicio_14:
"p∧q ⟹ p"
oops

lemma ejercicio_15:
"p∧q ⟹ q"
oops

lemma ejercicio_16:
"p∧(q∧r) ⟹ (p∧q)∧r"
oops

lemma ejercicio_17:
"(p∧q)∧r ⟹ p∧(q∧r)"
oops

lemma ejercicio_18:
"p∧q ⟹ p⟶q"
oops

lemma ejercicio_19:
"(p⟶q)∧(p⟶r) ⟹ p⟶q∧r"
oops

lemma ejercicio_20:
"p⟶q∧r ⟹ (p⟶q)∧(p⟶r)"
oops

lemma ejercicio_21:
"p⟶(q⟶r) ⟹ p∧q⟶r"
oops

lemma ejercicio_22:
"p∧q⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_23:
"(p⟶q)⟶r ⟹ p∧q⟶r"
oops

lemma ejercicio_24:
"p∧(q⟶r) ⟹ (p⟶q)⟶r"
oops

lemma ejercicio_25:
"p ⟹ p∨q"
oops

lemma ejercicio_26:
"q ⟹ p∨q"
oops

lemma ejercicio_27:
"p∨q ⟹ q∨p"
oops

lemma ejercicio_28:
"q⟶r ⟹ p∨q⟶p∨r"
oops

lemma ejercicio_29:
"p∨p ⟹ p"
oops

lemma ejercicio_30:
"p ⟹ p∨p"
oops

lemma ejercicio_31:
"p∨(q∨r) ⟹ (p∨q)∨r"
oops

lemma ejercicio_32:
"(p∨q)∨r ⟹ p∨(q∨r)"
oops

lemma ejercicio_33:
"p∧(q∨r) ⟹ (p∧q)∨(p∧r)"
oops

lemma ejercicio_34:
"(p∧q)∨(p∧r) ⟹ p∧(q∨r)"
oops

lemma ejercicio_35:
"p∨(q∧r) ⟹ (p∨q)∧(p∨r)"
oops

lemma ejercicio_36:
"(p∨q)∧(p∨r) ⟹ p∨(q∧r)"
oops

lemma ejercicio_37:
"(p⟶r)∧(q⟶r) ⟹ p∨q⟶r"
oops

lemma ejercicio_38:
"p∨q⟶r ⟹ (p⟶r)∧(q⟶r)"
oops

lemma ejercicio_39:
"p ⟹ ¬¬p"
oops

lemma ejercicio_40:
"¬p ⟹ p⟶q"
oops

lemma ejercicio_41:
"p⟶q ⟹ ¬q⟶¬p"
oops

lemma ejercicio_42:
"⟦p∨q; ¬q⟧ ⟹ p"
oops

lemma ejercicio_43:
"⟦p∨q; ¬p⟧ ⟹ q"
oops

lemma ejercicio_44:
"p∨q ⟹ ¬(¬p∧¬q)"
oops

lemma ejercicio_45:
"p∧q ⟹ ¬(¬p∨¬q)"
oops

lemma ejercicio_46:
"¬(p∨q) ⟹ ¬p∧¬q"
oops

lemma ejercicio_47:
"¬p∧¬q ⟹ ¬(p∨q)"
oops

lemma ejercicio_48:
"¬p∨¬q ⟹ ¬(p∧q)"
oops

lemma ejercicio_49:
"¬(p∧¬p)"
oops

lemma ejercicio_50:
"p∧¬p ⟹ q"
oops

lemma ejercicio_51:
"¬¬p ⟹ p"
oops

lemma ejercicio_52:
"p∨¬p"
oops

lemma ejercicio_53:
"((p⟶q)⟶p)⟶p"
oops

lemma ejercicio_54:
"¬q⟶¬p ⟹ p⟶q"
oops

lemma ejercicio_55:
"¬(¬p∧¬q) ⟹ p∨q"
oops

lemma ejercicio_56:
"¬(¬p∨¬q) ⟹ p∧q"
oops

lemma ejercicio_57:
"¬(p∧q) ⟹ ¬p∨¬q"
oops

lemma ejercicio_58:"(p⟶q)∨(q⟶p)"
oops

end
</source>

Rel 1

2018-07-15T18:17:56Z

Jalonso:

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

theory Relacion_1
imports Main Efficient_Nat
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
------------------------------------------------------------------ *}

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 9. Se considera la siguiente definición iterativa de la
función factorial
factI :: Integer -> Integer
factI n = factI' n 1

factI' :: Integer -> Integer -> Integer
factI' 0 x = x -- factI'.1
factI' (n+1) x = factI' n (n+1)*x -- factI'.2
Comprobar con QuickCheck que factI y factR son equivalentes sobre los
números naturales.
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
y, como corolario, que
factI n = factR n
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 12. 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 [2,5] 3 = [2,5,3]
------------------------------------------------------------------ *}

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

end
</source>

Ejercicios

2018-07-15T18:17:42Z

Jalonso: /* Ejercicios de Demostración asistida por ordenador */

== Ejercicios de ''Demostración asistida por ordenador'' ==
* '''Tema 2:''' Razonamiento sobre programas ([[Rel_1|Enunciado]]).
* '''Tema 3:''' Deducción natural proposicional con Isabelle ([[Tema_3_ej|Enunciado]]).
* '''Tema 4:''' Deducción natural en lógica de primer orden con Isabelle ([[Tema_4_ej|Enunciado]]).

Tema 4: Deducción natural en lógica de primer orden con Isabelle

2018-07-15T18:16:51Z

Jalonso:

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

theory LogicaDePrimerOrdenEj
imports Main
begin

text {*
En esta teoría se presentan los ejemplos del tema de deducción natural
en lógica de primer orden siguiendo la presentación de Huth y Ryan en su
libro "Logic in Computer Science"
http://www.cs.bham.ac.uk/research/projects/lics/ y, más concretamente,
a la forma como se explica en la asignatura de "Lógica informática" y
que puede verse en http://www.cs.us.es/~jalonso/cursos/li/temas/tema-7.pdf
*}

text {*
Se usarán las reglas del modus tollen y de la introducción de la
doble negación.
*}

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

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

lemma
assumes "P(c)" and
"∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
proof (rule notI)
assume 1: "Q(c)"
have 2: "P(c) ⟶ ¬Q(c)" using assms(2) by (rule allE)
have 3: "¬¬Q(c)" using 1 by (rule notnotI)
have 4: "¬P(c)" using 2 3 by (rule mt)
thus "False" using assms(1) by (rule notE)
qed

lemma
assumes "∀x. (P x ⟶ ¬(Q x))" and
"∀x. P x"
shows "∀x. ¬(Q x)"
proof (rule allI)
fix x
have 1: "P x ⟶ ¬(Q x)" using assms(1) by (rule allE)
have 2: "P x" using assms(2) by (rule allE)
show "¬(Q x)" using 1 2 by (rule mp)
qed

lemma
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

lemma
assumes "∀x. (P x ⟶ Q x)" and
"∃x. P x"
shows "∃x. Q x"
proof -
obtain a where 1: "P a" using assms(2) by (rule exE)
have 2: "P a ⟶ Q a" using assms(1) by (rule allE)
have "Q a" using 2 1 by (rule mp)
thus "∃x. Q x" by (rule exI)
qed

lemma
assumes "∀x. (Q x ⟶ R x)" and
"∃x . (P x ∧ Q x)"
shows "∃x . (P x ∧ R x)"
proof -
obtain a where 1: "P a ∧ Q a" using assms(2) by (rule exE)
have 2: "Q a ⟶ R a" using assms(1) by (rule allE)
have 3: "Q a" using 1 by (rule conjunct2)
have 4: "R a" using 2 3 by (rule mp)
have 5: "P a" using 1 by (rule conjunct1)
hence "P a ∧ R a" using 4 by (rule conjI)
thus "∃x . (P x ∧ R x)" by (rule exI)
qed

lemma
assumes "∃x. P x" and
"∀x.∀y. (P x ⟶ Q y)"
shows "∀y. Q y"
proof (rule allI)
fix b
obtain a where 1: "P a" using assms(1) by (rule exE)
have "∀y. (P a ⟶ Q y)" using assms(2) by (rule allE)
hence "P a ⟶ Q b" by (rule allE)
thus "Q b" using 1 by (rule mp)
qed

lemma
assumes "∃x. ¬P x"
shows " ¬(∀x. P x)"
proof (rule notI)
assume 1: "∀x. P x"
obtain a where 2: "¬P a" using assms(1) by (rule exE)
have 3: "P a" using 1 by (rule allE)
show False using 2 3 by (rule notE)
qed

lemma
assumes "(∀x. P x) ∨ (∀x. Q x)"
shows "∀x. P x ∨ Q x"
using assms
proof (rule disjE)
{ assume 1: "∀x. P x"
show "∀x. P x ∨ Q x"
proof (rule allI)
fix x
have "P x" using 1 by (rule allE)
thus "P x ∨ Q x" by (rule disjI1)
qed }
next
{ assume 2: "∀x. Q x"
show "∀x. P x ∨ Q x"
proof (rule allI)
fix x
have "Q x" using 2 by (rule allE)
thus "P x ∨ Q x" by (rule disjI2)
qed }
qed

lemma
assumes "∀x. P x ⟶ Q x"
shows "(∀x. P x) ⟶ (∀x. Q x)"
proof (rule impI)
assume 1: "∀x. P x"
show "∀x. Q x"
proof (rule allI)
fix x
have 2: "P x ⟶ Q x" using assms by (rule allE)
have 3: "P x" using 1 by (rule allE)
show "Q x" using 2 3 by (rule mp)
qed
qed

lemma
assumes "∀x. P x"
shows "∀y. P y"
proof (rule allI)
fix a
show "P a" using assms(1) by (rule allE)
qed

lemma
assumes "∀x. P x ⟶ Q x"
shows "(∀x. ¬Q x) ⟶ (∀x. ¬P x)"
proof (rule impI)
assume 1: "∀x. ¬Q x"
show "∀x. ¬P x"
proof (rule allI)
fix x
have 2: "P x ⟶ Q x" using assms(1) by (rule allE)
have 3: "¬Q x" using 1 by (rule allE)
show "¬P x" using 2 3 by (rule mt)
qed
qed

lemma
assumes "∀x. P x ⟶ ¬Q x"
shows "¬(∃x. P x ∧ Q x)"
proof (rule notI)
assume "∃x. P x ∧ Q x"
then obtain a where 1: "P a ∧ Q a" by (rule exE)
have 2: "P a ⟶ ¬Q a" using assms(1) by (rule allE)
have 3: "P a" using 1 by (rule conjunct1)
have 4: "¬Q a" using 2 3 by (rule mp)
have 5: "Q a" using 1 by (rule conjunct2)
show False using 4 5 by (rule notE)
qed

lemma
assumes "∀x. ∀y. P x y"
shows "∀u. ∀v. P u v"
proof (rule allI)
fix u
show "∀v. P u v"
proof (rule allI)
fix v
have "∀y. P u y" using assms(1) by (rule allE)
thus "P u v" by (rule allE)
qed
qed

lemma
assumes "∃x. ∃y. P x y"
shows "∃u. ∃v. P u v"
proof -
obtain a where "∃y. P a y" using assms(1) by (rule exE)
then obtain b where "P a b" by (rule exE)
hence "∃v. P a v" by (rule exI)
thus "∃u. ∃v. P u v" by (rule exI)
qed

lemma
assumes "∃x. ∀y. P x y"
shows "∀y. ∃x. P x y"
proof (rule allI)
fix y
obtain a where "∀y. P a y" using assms(1) by (rule exE)
hence "P a y" by (rule allE)
thus "∃x. P x y" by (rule exI)
qed

lemma
assumes "∃x. P a ⟶ Q x"
shows "P a ⟶ (∃x. Q x)"
proof (rule impI)
assume 1: "P a"
obtain b where "P a ⟶ Q b" using assms(1) by (rule exE)
hence "Q b" using 1 by (rule mp)
thus "∃x. Q x" by (rule exI)
qed

lemma
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof -
have "¬P a ∨ P a" by (rule excluded_middle)
thus "∃x. P a ⟶ Q x"
proof (rule disjE)
{ assume "¬P a"
hence "P a ⟶ Q b" by simp
thus "∃x. P a ⟶ Q x" by (rule exI) }
next
{ assume "P a"
hence "∃x. Q x" using assms(1) by simp
then obtain c where "Q c" by (rule exE)
hence "P a ⟶ Q c" by simp
thus "∃x. P a ⟶ Q x" by (rule exI) }
qed
qed

lemma
assumes "(∃x. P x) ⟶ Q a"
shows "∀x. P x ⟶ Q a"
proof (rule allI)
fix x
show "P x ⟶ Q a"
proof
assume "P x"
hence 1: "∃x. P x" by (rule exI)
show "Q a" using assms(1) 1 by (rule mp)
qed
qed

lemma
assumes "∀x. P x ⟶ Q a"
shows "∃x. P x ⟶ Q a"
proof (rule exI)
show "P b ⟶ Q a" using assms(1) ..
qed

lemma
assumes "∃x. P x ∧ Q x"
shows "(∃x. P x) ∧ (∃x. Q x)"
proof -
obtain a where 1: "P a ∧ Q a" using assms(1) by (rule exE)
hence "P a" by (rule conjunct1)
hence 2: "∃x. P x" by (rule exI)
have "Q a" using 1 by (rule conjunct2)
hence 3: "∃x. Q x" by (rule exI)
show "(∃x. P x) ∧ (∃x. Q x)" using 2 3 by (rule conjI)
qed

lemma
assumes "∀x.∀y. P y ⟶ Q x"
shows "(∃y. P y) ⟶ (∀x. Q x)"
proof (rule impI)
assume 1: "∃y. P y"
show "∀x. Q x"
proof (rule allI)
fix x
have 2: "∀y. P y ⟶ Q x" using assms by (rule allE)
obtain b where 3: "P b" using 1 by (rule exE)
have "P b ⟶ Q x" using 2 by (rule allE)
thus "Q x" using 3 by (rule mp)
qed
qed

lemma
assumes "¬(∀x. ¬P x)"
shows "∃x. P x"
proof (rule ccontr)
assume 1: "¬(∃x. P x)"
have 2: "∀x. ¬P x"
proof
fix x
show "¬P x"
proof
assume "P x"
hence 3: "∃x. P x" by (rule exI)
show False using 1 3 by (rule notE)
qed
qed
show False using assms(1) 2 by (rule notE)
qed

lemma
assumes "∀x. ¬P x"
shows "¬(∃x. P x)"
proof (rule notI)
assume "∃x. P x"
then obtain a where 1: "P a" by (rule exE)
have "¬P a" using assms(1) by (rule allE)
thus False using 1 by (rule notE)
qed

lemma
assumes "∃x. P x"
shows "¬(∀x. ¬P x)"
proof (rule notI)
assume 1: "∀x. ¬P x"
obtain a where 2: "P a" using assms(1) by (rule exE)
have "¬P a" using 1 by (rule allE)
thus False using 2 by (rule notE)
qed

lemma
assumes "P a ⟶ (∀x. Q x)"
shows "∀x. P a ⟶ Q x"
proof (rule allI)
fix x
show "P a ⟶ Q x"
proof
assume 1: "P a"
have "∀x. Q x" using assms(1) 1 by (rule mp)
thus "Q x" by (rule allE)
qed
qed

lemma
assumes "∀x.∀y.∀z. R x y ∧ R y z ⟶ R x z" and
"∀x. ¬R x x"
shows "∀x.∀y. R x y ⟶ ¬R y x"
proof (rule allI)
fix x
show "∀y. R x y ⟶ ¬R y x"
proof (rule allI)
fix y
show "R x y ⟶ ¬R y x"
proof (rule impI)
assume 1: "R x y"
show "¬R y x"
proof
assume 2: "R y x"
have "∀y.∀z. R x y ∧ R y z ⟶ R x z" using assms(1) by (rule allE)
hence "∀z. R x y ∧ R y z ⟶ R x z" by (rule allE)
hence 3: "R x y ∧ R y x ⟶ R x x" by (rule allE)
have 4: "R x y ∧ R y x" using 1 2 by (rule conjI)
have 5: "R x x" using 3 4 by (rule mp)
have "¬R x x" using assms(2) by (rule allE)
thus False using 5 by (rule notE)
qed
qed
qed
qed

lemma
assumes "∀x. P x ∨ Q x" and
"∃x. ¬Q x" and
"∀x. R x ⟶ ¬P x"
shows "∃x. ¬R x"
proof -
obtain a where 1: "¬Q a" using assms(2) ..
have "P a ∨ Q a" using assms(1) ..
thus "∃x. ¬R x"
proof (rule disjE)
{ assume "P a"
hence 2: "¬¬P a" by (rule notnotI)
have "R a ⟶ ¬P a" using assms(3) by (rule allE)
hence "¬R a" using 2 by (rule mt)
thus "∃x. ¬R x" by (rule exI) }
next
{ assume 3: "Q a"
show "∃x. ¬R x" using 1 3 by (rule notE) }
qed
qed

lemma
assumes "∀x. P x ⟶ Q x ∨ R x" and
"¬(∃x. P x ∧ R x)"
shows "∀x. P x ⟶ Q x"
proof
fix x
show "P x ⟶ Q x"
proof
assume 1: "P x"
have "P x ⟶ Q x ∨ R x" using assms(1) by (rule allE)
hence "Q x ∨ R x" using 1 by (rule mp)
thus "Q x"
proof (rule disjE)
{ assume "Q x"
thus "Q x" by this }
next
{ assume 2: "R x"
have "P x ∧ R x" using 1 2 by (rule conjI)
hence 3: "∃x. P x ∧ R x" by (rule exI)
show "Q x" using assms(2) 3 by (rule notE) }
qed
qed
qed

lemma
assumes "∃x.∃y. R x y ∨ R y x"
shows "∃x.∃y. R x y"
proof -
obtain a where "∃y. R a y ∨ R y a" using assms(1) by (rule exE)
then obtain b where "R a b ∨ R b a" by (rule exE)
thus "∃x.∃y. R x y"
proof
{ assume "R a b"
hence "∃y. R a y" by (rule exI)
thus "∃x.∃y. R x y" by (rule exI) }
next
{ assume "R b a"
hence "∃y. R b y" by (rule exI)
thus "∃x.∃y. R x y" by (rule exI) }
qed
qed

end
</source>

Tema 3: Deducción lógica proposicional con Isabelle

2018-07-15T18:16:35Z

Jalonso:

<source lang="isabelle">
header {* Deducción natural proposicional *}

theory Tema_3
imports Main
begin

text {*
En esta teoría 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://www.cs.bham.ac.uk/research/projects/lics/ y, más concretamente,
a la forma como se explica en la asignatura de "Lógica informática" y
que puede verse en
http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf

La página al lado de cada teorema indica la página de las anteriores
transparencias donde se encuentra la demostración.
*}

section {* Reglas de la conjunción *}

text {*
La regla de introducción de la conjunción es
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
Las reglas de eliminación de la conjunción son
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
*}

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

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

section {* 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
que, de momento, no detallamos su demostración.
*}

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

lemma -- "p. 5"
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 "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

section {* Regla de eliminación del condicional *}

text {*
La regla de eliminación del condicional es la regla del modus ponens
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
*}

lemma -- "p. 6"
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

lemma -- "p. 6"
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 "r" using 5 4 by (rule mp)
qed

section {* Regla derivada del modus tollens *}

text {*
Para ajustarnos al tema de LI vamos a introducir la regla del modus
tollens
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
sin, de momento, detallar su demostración.
*}

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

lemma -- "p. 7"
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

lemma -- "p. 7"
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

lemma
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

section {* Regla de introducción del condicional *}

text {*
La regla de introducción del condicional es
· impI: (P ⟹ Q) ⟹ P ⟶ Q
*}

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 3: "¬q"
have "¬p" using 1 3 by (rule mt)
} thus "¬q ⟶ ¬p" by (rule impI)
qed

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 3: "¬q"
show "¬p" using 1 3 by (rule mt)
qed

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume 3: "¬q"
show "¬p" using 1 3 by (rule mt)
qed

lemma -- "p. 9"
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

lemma -- "p. 9"
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof (rule impI)
assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
show "¬¬q" using 1 3 by (rule mt)
qed

lemma -- "p. 9"
"p ⟶ p"
proof (rule impI)
qed

lemma -- "p. 10"
"(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

lemma -- "p. 10"
"(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

lemma
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

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

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

section {* Reglas de la disyunción *}

text {*
Las reglas de la introducción de la disyunción son
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
La regla de elimación de la disyunción es
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
*}

lemma -- "p. 11"
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

lemma -- "p. 12"
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

lemma
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1
proof (rule disjE)
{ assume 2: "p ∨ q"
thus "p ∨ (q ∨ r)"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ (q ∨ r)" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "q ∨ r" using 4 by (rule disjI1)
show "p ∨ (q ∨ r)" using 5 by (rule disjI2) }
qed }
next
{ assume 6: "r"
have 7: "q ∨ r" using 6 by (rule disjI2)
show "p ∨ (q ∨ r)" using 7 by (rule disjI2) }
qed

lemma
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: "p" using 1 ..
have "q ∨ r" using 1 ..
thus "(p ∧ q) ∨ (p ∧ r)"
proof (rule disjE)
{ assume 3: "q"
have "p ∧ q" using 2 3 by (rule conjI)
thus "(p ∧ q) ∨ (p ∧ r)" by (rule disjI1) }
next
{ assume 4: "r"
have "p ∧ r" using 2 4 by (rule conjI)
thus "(p ∧ q) ∨ (p ∧ r)" by (rule disjI2) }
qed
qed

section {* Regla de copia *}

lemma -- "p. 13"
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof
assume "q"
show "p" using 1 by this
qed
qed

lemma -- "p. 13"
"p ⟶ (q ⟶ p)"
proof
assume "p"
thus "q ⟶ p" by (rule impI)
qed

section {* Reglas de la negación *}

text {*
La regla de eliminación de lo falso es
· FalseE: False ⟹ P
La regla de eliminación de la negación es
· notE: ⟦¬P; P⟧ ⟹ R
La regla de introducción de la negación es
· notI: (P ⟹ False) ⟹ ¬P
*}

lemma -- "p. 15"
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof
assume 2: "p"
note 1
thus "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume "q"
thus "q" by this}
qed
qed

lemma -- "p. 16"
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

lemma
assumes 1: "p ⟶ ¬p"
shows "¬p"
proof (rule notI)
assume 2: "p"
have 3: "¬p" using 1 2 by (rule mp)
show False using 3 2 by (rule notE)
qed

lemma
assumes 1: "p ∧ ¬q ⟶ r" and
2: "¬r" and
3: "p"
shows "q"
proof -
have "¬¬q"
proof (rule notI)
assume 4: "¬q"
have 5: "p ∧ ¬q" using 3 4 by (rule conjI)
have 6: "r" using 1 5 by (rule mp)
show False using 2 6 by (rule notE)
qed
thus "q" by (rule notnotD)
qed

lemma
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof (rule notI)
assume 4: "q"
have 5: "q ⟶ r" using 1 2 by (rule mp)
have 6: "r" using 5 4 by (rule mp)
show False using 3 6 by (rule notE)
qed

section {* Reglas del bicondicional *}

text {*
La regla de introducción del bicondicional es
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
Las reglas de eliminación del bicondicional son
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
*}

lemma -- "p. 17"
"(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

lemma -- "p. 18"
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

section {* Reglas derivadas *}

subsection {* Regla del modus tollens *}

lemma -- "p. 20"
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

subsection {* Regla de la introducción de la doble negación *}

lemma -- "p. 21"
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

subsection {* Regla de reducción al absurdo *}

lemma -- "p. 22"
assumes 1: "¬F ⟶ False"
shows "F"
proof -
have 2: "¬¬F"
proof (rule notI)
assume 3: "¬F"
show False using 1 3 by (rule mp)
qed
show "F" using 2 by (rule notnotD)
qed

text {*
La regla de reducción al absurdo en Isabelle se correponde con la
regla de contradicción
· ccontr: (¬P ⟹ False) ⟹ P
*}

subsection {* Ley del tercio excluso *}

text {*
La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
Puede demostrarse como se muestra a continuación.
*}

lemma -- "p. 23"
"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

lemma -- "p. 24"
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

end
</source>

Tema 2: Razonamiento sobre programas

2018-07-15T18:16:18Z

Jalonso:

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

theory Tema_2
imports Main Efficient_Nat
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://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8t.pdf
*}

text {* ----------------------------------------------------------------
Ejercicio 1. Definir, por recursión, la función
longitud :: "'a list ⇒ nat" where
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 {* ---------------------------------------------------------------
Ejercicio 2. Demostrar que
longitud [4,2,5] = 3
------------------------------------------------------------------- *}

lemma "longitud [4,2,5] = 3"
by simp

text {* ---------------------------------------------------------------
Ejercicio 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 (2,3) = (3,2)
------------------------------------------------------------------ *}

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

value "intercambia (2,3)" -- "= (3,2)"

text {* ---------------------------------------------------------------
Ejercicio 4. Demostrar que
intercambia (intercambia (x,y)) = (x,y)
------------------------------------------------------------------- *}

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 6. Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

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

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
repite :: "nat ⇒ 'a ⇒ 'a list" where
tal que . Por ejemplo,
repite 3 5 = [5,5,5]
------------------------------------------------------------------ *}

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

value "repite 3 5" -- "= [5,5,5]"

text {* ---------------------------------------------------------------
Ejercicio 8. Demostrar que
longitud (repite n x) = n
------------------------------------------------------------------- *}

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

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
fun conc :: "'a list ⇒ 'a list ⇒ 'a list"
tal que . Por ejemplo,
conc [2,3] [4,3,5] = [2,3,4,3,5]
------------------------------------------------------------------ *}

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

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

text {* ---------------------------------------------------------------
Ejercicio 10. 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 {* ---------------------------------------------------------------
Ejercicio 11. Refutar que
conc xs ys = conc ys xs
------------------------------------------------------------------- *}

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

text {* Encuentra el contraejemplo,
xs = [a\<^isub>2]
ys = [a\<^isub>1] *}

text {* ---------------------------------------------------------------
Ejercicio 12. Demostrar que
conc xs [] = xs
------------------------------------------------------------------- *}

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

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

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

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

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 [3,7,5,4]" -- "= [3,7]"

text {* ---------------------------------------------------------------
Ejercicio 15. Definir la función
elimina :: "nat ⇒ 'a list ⇒ 'a list"
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
elimina 2 [3,7,5,4] = [5,4]
------------------------------------------------------------------ *}

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 [3,7,5,4]" -- "= [5,4]"

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

text {* coge.induct es el esquema de inducción asociado a la definición
de la función coge. Puede verse como sigue: *}

thm coge.induct

text {* ---------------------------------------------------------------
Ejercicio 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 {* ---------------------------------------------------------------
Ejercicio 18. Demostrar que
esVacia xs = esVacia (conc xs xs)
------------------------------------------------------------------- *}

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

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

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 [3,2,5]" -- "= [5,2,3]"

text {* ---------------------------------------------------------------
Ejercicio 20. 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 {* ---------------------------------------------------------------
Ejercicio 21. Demostrar que
inversaAc xs = inversa xs
------------------------------------------------------------------- *}

corollary "inversaAc xs = inversa xs"
by (simp add: inversaAcAux_es_inversa)

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 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::int,2,5]" -- "= [6,4,10]"

text {* ---------------------------------------------------------------
Ejercicio 24. 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 {* ---------------------------------------------------------------
Ejercicio 25. Demostrar que
longitud (map f xs) = longitud xs
------------------------------------------------------------------- *}

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

end
</source>

Tema 1: Isabelle como un lenguaje funcional

2018-07-15T18:16:00Z

Jalonso:

<source lang="isabelle">
header {* Isabelle como un lenguaje funcional *}

theory Tema_1
imports Main Efficient_Nat
begin

section {* Introducción *}

text {* Esta notas son una introducción a la demostración asistida
utilizando el sistema Isabelle/HOL/Isar. La versión de Isabelle
utilizada es la 2011.

En este capítulos 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 {* Todo elemento es igual a sí mismo. *}
lemma "∀x. x = x"
by simp

text {* 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 exlusiva al conjunto de
reglas de simplificación automáticas. *}

declare xor_def[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 coma.

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 3, 2 y 1 es [1,2,3]. *}

value "1#(2#(3#[]))" -- "= [1,2,3]"

text {* Funciones de descomposió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 de números naturales [1,2,3], entonces
el primero de xs es 1 y el resto de xs es [2,3]. *}

value "let l = [1,2,3]::(nat list) in hd l = 1 ∧ tl l = [2,3]" -- "= 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 38 de "HOL: The basis of Higher-Order Logic" se
encuentran más definiciones y propiedades de las listas. *}

section {* Registros *}

text {* Un registro es una colección de campos y valores.

Por ejemplo, los puntos del plano pueden representarse mediante
registros con dos campos, las coordenadas, con valores enteros. *}

record punto =
coordenada_x :: int
coordenada_y :: int

text {* Ejemplo, el punto pt tiene de coordenadas 3 y 7. *}

definition pt :: punto where
"pt ≡ (|coordenada_x = 3, coordenada_y = 7|)"

text {* Ejemplo, la coordenada x del punto pt es 3. *}

value "coordenada_x pt" -- "= 3"

text {* Ejemplo, sea pt2 el punto obtenido a partir del punto pt
cambiando el valor de su coordenada x por 4. Entonces la coordenada x
del punto pt2 es 4. *}

value "let pt2=pt(|coordenada_x:=4|) in coordenada_x (pt2)" -- "= 4"

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 recursión primitiva *}

text {* Una lista de elementos de tipo a es la lista Vacia o se obtiene
añadiendo, con ConsLista, un elemento de tipo a a una lista de
elementos de tipo a. *}

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

text {* (conc xs ys) es la concatenación de las lista xs e ys. *}

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

text {* Ejemplo, la concatenación de la lista formada por 1 y 2 con la
lista formada por el 3 es la lista cuyos elementos son 1, 2 y 3. *}

value "conc (ConsLista 1 (ConsLista 2 Vacia)) (ConsLista 3 Vacia) =
(ConsLista 1 (ConsLista 2 (ConsLista 3 Vacia)))" -- "= True"

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

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

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

value "sumaImpares 3" -- "= 9"

text {* Prop.: La suma de los n primeros numeros impares es n\<^sup>2
Dem.: Por induccion en n. *}

lemma "sumaImpares n = n * n"
by (induct n) auto

end
</source>

MediaWiki:Common.css

2018-07-15T18:15:25Z

Jalonso: 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");

Tema 9: Patrones de demostración

2012-02-09T14:01:24Z

Jalonso:

<source lang="isar">
header {* Tema 9: Patrones de demostración *}

theory Tema_9
imports Main
begin

section {* Demostraciones por casos *}

text {*
Nota. [Regla de eliminación de la disyunción]
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R

Lema. [Ejemplo de demostración por casos]
P ∨ Q ⟹ Q ∨ P
*}

lemma disj_conmutativa: "P ∨ Q ⟹ Q ∨ P"
proof -
assume "P ∨ Q"
thus "Q ∨ P"
proof (rule disjE)
assume P
thus ?thesis by (rule disjI2)
next
assume Q
thus ?thesis by (rule disjI1)
qed
qed

text {*
Nota. El lema anterior puede demostrarse automáticamente como se
muestra a continuación.
*}

lemma disj_conmutativa_auto: "P ∨ Q ⟹ Q ∨ P"
by auto

section {* Negación *}

text {*
Reglas de la negación:
· notI: (P ⟹ False) ⟹ ¬P
· notE: ⟦¬P; P⟧ ⟹ R

Lema. [Ejemplo de demostración con negaciones]
Si x²+y = 13 e y ≠ 4, entonces x ≠ 3.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
proof (rule notI)
assume "x = 3"
with 1 have "y = 4" by simp
with 2 show "False" by (rule notE)
qed

text {*
La demostración puede hacerse automáticamente como se muestra a
continuación.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
proof (rule notI)
assume "x = 3"
with 1 2 show "False" by auto
qed

text {*
El lema anterior puede demostrarse más automáticamente como se muestra a
continuación.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
using assms
by auto

section {* Contradicciones *}

text {*
Regla de contradicción:
· FalseE: False ⟹ P

Lema. [Ejemplo de uso de la regla de contradicción]
Si 1=2, entonces 3=7.
*}

lemma
assumes "1 = (2::nat)"
shows "3 = (7::nat)"
proof -
have "False" using assms by simp
thus "3 = (7::nat)" by (rule FalseE)
qed

text {*
El lema puede demostrarse automáticamente, como sigue.
*}

lemma
assumes "1 = (2::nat)"
shows "3 = (7::nat)"
using assms
by auto

text {*
Lema. [Ejemplo de demostración por casos y contradicción]
¬P, P ∨ Q ⊢ Q
*}

lemma disjCE:
assumes "¬P" and "P ∨ Q"
shows "Q"
using `P ∨ Q`
proof (rule disjE)
assume "P"
thus "Q" using `¬P` by contradiction
next
assume "Q"
thus "Q" by assumption
qed

section {* Equivalencias *}

text {*
Reglas de equivalencia:
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P

Lema. [Ejemplo de introducción de equivalencia]
La fórmula
(R ⟶ C) ∧ (S ⟶ C))
es equivalente a
R ∨ S ⟶ C
*}

lemma "((R ⟶ C) ∧ (S ⟶ C)) = (R ∨ S ⟶ C)"
proof (rule iffI)
assume "(R ⟶ C) ∧ (S ⟶ C)"
thus "R ∨ S ⟶ C" by blast
next
assume "R ∨ S ⟶ C"
thus "(R ⟶ C) ∧ (S ⟶ C)" by blast
qed

text {*
El método "blast":
En la demostración anterior es la primera vez que se usa el método de
razonamiento automático "blast".

Nota. El lema anterior puede demostrarse automáticamente como se
muestra a continuación.
*}

lemma "((R ⟶ C) ∧ (S ⟶ C)) = (R ∨ S ⟶ C)"
by auto

text {*
Lema. [Ejemplo de eliminación de equivalencia]
· A ⟷ B, A ⊢ B
· A ⟷ B, B ⊢ A
*}

lemma assumes "A = B" and "A" shows "B"
using assms
by (rule iffD1)

lemma assumes "A = B" and "B" shows "A"
using assms
by (rule iffD2)

end
</source>

Tema 8: Distinción de casos e inducción

2012-02-09T13:55:05Z

Jalonso:

<source lang="isar">
header {* Tema 8: Distinción de casos e inducción *}

theory Tema_8
imports Main Parity
begin

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Lema. [Demostración por distinción de casos booleanos]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof cases
assume "A" thus ?thesis ..
next
assume "¬A" thus ?thesis ..
qed

text {*
Lema. [Demostración por distinción de casos booleanos nominados]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof (cases "A")
case True thus ?thesis ..
next
case False thus ?thesis ..
qed

text {*
El método "cases" sobre una fórmula:
· 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 {*
Lema. [Distinción de casos sobre listas]
La longitud del resto de una lista es la longitud de la lista menos 1.
*}

lemma "length(tl xs) = length xs - 1"
proof (cases xs)
case Nil thus ?thesis by simp
next
case Cons thus ?thesis by simp
qed

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.

Lema. [Ejemplo de análisis de casos]
El resultado de eliminar los n+1 primeros elementos de xs es el mismo
que eliminar los n primeros elementos del resto de xs.
*}

lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil thus "drop (n + 1) xs = drop n (tl xs)" by simp
next
case Cons thus "drop (n + 1) xs = drop n (tl xs)" by simp
qed

text {*
La función drop 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
primrec drop:: "nat => 'a list => 'a list" where
drop_Nil: "drop n [] = []" |
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

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

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

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

text {*
Lema. [Ejemplo de suma de impares]
La suma de los 3 primeros números impares es 9.
*}

lemma "suma_impares 2 = 4"
by (simp add: suma_impares_def)

text {*
La suma de los 3 primero número impares se puede calcular mediante "value".
*}

value "suma_impares 3"

text {*
Lema. [Ejemplo de demostración por inducción matemática]
La suma de los n primeros números impares es n^2.

Demostración automática: Por inducción en n.
*}

lemma "suma_impares n = n * n"
by (induct n) simp_all

text {*
En la demostración "by (induct n) simp_all" se aplica inducción en n y
los dos casos se prueban por simplificación.

Demostración del lema anterior usando patrones.
*}

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

text {*
Patrones: Cualquier fórmula seguida de (is patrón) equipara el patrón
con la fórmula.

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

text {*
Definición. [Números pares]
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 {*
Lema. [Ejemplo de inducción y existenciales]
Para todo número natural n, se verifica que n*(n+1) par.
*}

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))"
hence "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" by (rule exE)
hence "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
hence "∃m. (Suc n)*((Suc n)+1) = m+m" by (rule exI)
thus "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

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

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

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)
thus "par n = even n" by presburger
qed

text {*
En la demostración anterior hemos usado la táctica "presburger" que
corresponde a 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.

Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
primrec
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"

Lema. [Ejemplo de inducción sobre listas]
La concatenación de listas es asociativa.

Demostración automática del lema.
*}

lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

text {*
Demostración estructurada del lema anterior.
*}

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

text {*
Ejercicio. [Árboles binarios]
Definir un tipo de dato para los árboles binarios.
*}

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

text {*
Ejercicio. [Imagen especular]
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

primrec espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (Hoja a) = (Hoja a)"
| "espejo (Nodo f x y) = (Nodo f (espejo y) (espejo x))"

text {*
Ejercicio. [La imagen especular es involutiva]
Demostrar que la función "espejo" involutiva; es decir, para cualquier
árbol t, se tiene que
espejo (espejo(t)) = t.

Demostración automática del lema.
*}

lemma espejo_involutiva_1: "espejo(espejo(t)) = t"
by (induct t) auto

text {*
Demostración estructurada del lema.
*}

lemma espejo_involutiva: "espejo(espejo(t)) = t" (is "?P t")
proof (induct t)
fix x :: 'a show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "espejo(espejo(Nodo x t1 t2)) = espejo(Nodo x (espejo t2) (espejo t1))"
by simp
also have "… = Nodo x (espejo (espejo t1)) (espejo (espejo t2))" by simp
also have "… = Nodo x t1 t2" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Ejercicio. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.
*}

primrec aplana :: "'a arbol ⇒ 'a list" where
"aplana (Hoja a) = [a]"
| "aplana (Nodo x t1 t2) = (aplana t1)@[x]@(aplana t2)"

text {*
Ejercicio. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo t) = rev (aplana t)

Demostración automática del lema.
*}

lemma "aplana (espejo t) = rev (aplana t)"
by (induct t) auto

text {*
Demostración estructurada del lema anterior.
*}

lemma "aplana (espejo t) = rev (aplana t)" (is "?P t")
proof (induct t)
fix x :: 'a
show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "aplana (espejo (Nodo x t1 t2)) =
aplana (Nodo x (espejo t2) (espejo t1))" by simp
also have "… = (aplana(espejo t2))@[x]@(aplana(espejo t1))" by simp
also have "… = (rev(aplana t2))@[x]@(rev(aplana t1))" using h1 h2 by simp
also have "… = rev((aplana t1)@[x]@(aplana t2))" by simp
also have "… = rev(aplana (Nodo x t1 t2))" by simp
finally show ?thesis .
qed
qed

end
</source>

Tema 7: El lenguaje de demostración Isar

2012-02-02T18:33:25Z

Jalonso:

<source lang="isar">
header {* Tema 7: El lenguaje de demostración Isar *}

theory Tema_7
imports Main
begin

text {*
Este tema describe los elementos básicos del lenguaje de demostración
Isar (Intelligible semi-automated reasoning).
*}

section {* Panorama de la sintaxis (simplificada) de Isar *}

text {*
Representación de lemas (y teoremas)
· Un lema (o teorema) comienza con una etiqueta seguida por algunas
premisas y una conclusión.
· Las premisas se introducen con la palabra "assumes" y se separan
con "and".
· Cada premisa puede etiquetarse para referenciarse en la demostración.
· La conclusión se introduce con la palabra "shows".

Gramática (simplificada) de las demostraciones en Isar
<demostración> ::= proof <método> <declaración>* qed
| by <método>
<declaración> ::= fix <variable>+
| assume <proposición>+
| (from <hecho>+)? have <proposición>+ <demostración>
| (from <hecho>+)? show <proposición>+ <demostración>
<proposición> ::= (<etiqueta>:)? <cadena>
hecho ::= <etiqueta>
método ::= -
| this
| rule <hecho>
| simp
| blast
| auto
| induct <variable>

La declaración "show" demuestra la conclusión de la demostración
mientras que la declaración "have" demuestra un resultado intermedio.
*}

section {* Razonamiento proposicional *}

text {*
Regla de introducción de la conjunción:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q

Nota: Se puede consultar mediante
thm conjI

Lema. [Ejemplo de introducción de conjunción con razonamiento progresivo]
P, Q ⊢ P ∧ (Q ∧ P)

Demostración. Estamos suponiendo
P (1)
y
Q (2)
De (2) y (1), por introducción de la conjunción, se tiene
Q ∧ P (3)
De (1) y (3), por introducción de la conjunción, se tiene
P ∧ (Q ∧ P)
*}

lemma conj2:
assumes 1: P and 2: "Q"
shows "P ∧ (Q ∧ P)"
proof -
from 2 1 have 3: "Q ∧ P" by (rule conjI)
from 1 3 show "P ∧ (Q ∧ P)" by (rule conjI)
qed

text {*
Razonamiento progresivo y regresivo en Isabelle:
· Isabelle soporta razonamiento progresivo. La anterior demostración
es una muestra.
· Isabelle soporta razonamiento regresivo. La siguiente demostración
es una muestra.

Lema. [Ejemplo de introducción de la conjunción con razonamiento regresivo]
P, Q ⊢ P ∧ (Q ∧ P)

Demostración. Estamos suponiendo
P (1)
y
Q (2)

Para demostrar el lema, por introducción de la conjunción, basta probar
P
y
Q ∧ P (3)

La condición 'P' se tiene por la hipótesis (1). Para demostrar
la condición (3), por introducción de la conjunción, basta probar
Q
y
P
La condición 'Q' se tiene por la hipótesis (2) y la condición 'P' se
tiene por la hipótesis (1).
*}

lemma
assumes 1: "P" and 2: "Q"
shows "P ∧ (Q ∧ P)"
proof (rule conjI)
from 1 show "P" by this
next
show "Q ∧ P"
proof (rule conjI)
from 2 show "Q" by this
next
from 1 show "P" by this
qed
qed

text {*
El método "this" demuestra el objetivo usando el hecho actual; es
decir, el de la cláusula "from".

Reglas de eliminación de la conjunción:
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q

Regla de introducción de la implicación:
· impI: (P ⟹ Q) ⟹ P ⟶ Q

Lema. [Ejemplo de razonamiento híbrido]
Sean a y b dos números naturales. Si 0 < a y a < b, entonces a*a < b*b.
*}

lemma
fixes a b :: "nat"
shows "0 < a ∧ a < b ⟶ a * a < b * b"
proof (rule impI)
assume x: "0 < a ∧ a < b"
from x have za: "0 < a" by (rule conjunct1)
from x have ab: "a < b" by (rule conjunct2)
from za ab have aa: "a*a < a*b" by simp
from ab have bb: "a*b < b*b" by simp
from aa bb show "a*a < b*b" by arith
qed

text {*
Modus ponens:
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q

Reglas de introducción de la disyunción:
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q

Regla de eliminación de la disyunción:
. disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R

Lema. [Razonamiento por casos]
A ∨ B, A ⟶ C, B ⟶ C ⊢ C
*}

lemma
assumes ab: "A ∨ B" and ac: "A ⟶ C" and bc: "B ⟶ C"
shows "C"
proof -
note ab
moreover {
assume a: "A"
from ac a have "C" by (rule mp) }
moreover {
assume b: "B"
from bc b have "C" by (rule mp) }
ultimately show "C" by (rule disjE)
qed

text {*
Resumen de reglas proposicionales:
· TrueI: True
· FalseE: False ⟹ P
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· conjE: ⟦P ∧ Q; ⟦P; Q⟧ ⟹ R⟧ ⟹ R
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· notE: ⟦¬P; P⟧ ⟹ R
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· impE: ⟦P ⟶ Q; P; Q ⟹ R⟧ ⟹ R
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· iff: (P ⟶ Q) ⟶ (Q ⟶ P) ⟶ P = Q
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· iffE: ⟦P = Q; ⟦P ⟶ Q; Q ⟶ P⟧ ⟹ R⟧ ⟹ R
· ccontr: (¬P ⟹ False) ⟹ P
· classical: (¬P ⟹ P) ⟹ P
· exlude_middle: ¬P ∨ P
· disjCI: (¬Q ⟹ P) ⟹ P ∨ Q
· impCE: ⟦P ⟶ Q; ¬P ⟹ R; Q ⟹ R⟧ ⟹ R
· iffCE: ⟦P = Q; ⟦P; Q⟧ ⟹ R; ⟦¬P; ¬Q⟧ ⟹ R⟧ ⟹ R
· notnotD: ¬¬P ⟹ P
· swap: ⟦¬P; ¬R ⟹ P⟧ ⟹ R

Referencia de reglas de inferencia: Más información sobre las reglas
de inferencia se encuentra en la sección 2.2 de "Isabelle's Logics:
HOL".
*}

section {* Atajos de Isar *}

text {*
Isar tiene muchos atajos, como los siguientes:
this | éste | el hecho probado en la declaración anterior
then | entonces | from this
hence | por lo tanto | then have
thus | de esta manera | then show
with hecho+ | con | from hecho+ and this
. | por ésto | by this
.. | trivialmente | by regla (Isabelle adivina la regla)

Razonamiento acumulativo:
Una sucesión de hechos que se van a usar como premisa en una declaración
puede agruparse usando "moreover" (además) y usarse en la declaración
usando "ultimately" (finalmente).

Lema. [Ejemplo de uso de atajos y razonamiento acumulativo]
A ∧ B ⊢ B ∧ A.
*}

lemma "A ∧ B ⟶ B ∧ A"
proof (rule impI)
assume ab: "A ∧ B"
hence "B" by (rule conjunct2)
moreover from ab have "A" ..
ultimately show "B ∧ A" by (rule conjI)
qed

section {* Cuantificadores universal y existencial *}

thm allE
text {*
Reglas del cuantificador universal:
· allI: (⋀x. P x) ⟹ ∀x. P x
· allE: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
En la regla allI la nueva variable se introduce mediante la palabra "fix".

Lema. [Ejemplo con cuantificadores universales]
∀x. P ⟶ Q x ⊢ P ⟶ (∀x. Q x)
*}

lemma
assumes a: "∀ x. P ⟶ Q x"
shows "P ⟶ (∀ x. Q x)"
proof (rule impI)
assume p: "P"
show "∀ x. Q x"
proof (rule allI)
fix y
from a have pq: "P ⟶ Q y" by (rule allE)
from pq p show "Q y" by (rule mp)
qed
qed

text {*
Reglas del cuantificador existencial:
· exI: P x ⟹ ∃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)"

Lema. [Ejemplo con cuantificador existencial y demostración progresiva]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))
*}

lemma
assumes e: "∃ x. P ∧ Q(x)"
shows "P ∧ (∃ x. Q(x))"
proof -
from e obtain y where f: "P ∧ Q(y)" by (rule exE)
from f have p: "P" by (rule conjunct1)
from f have q: "Q(y)" by (rule conjunct2)
from q have eq: "∃ x. Q(x)" by (rule exI)
from p eq show "P ∧ (∃ x. Q(x))" by (rule conjI)
qed

text {*
Lema. [Ejemplo con cuantificador existencial y demostración automática]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))
*}

lemma
assumes e: "∃ x. P ∧ Q(x)"
shows "P ∧ (∃ x. Q(x))"
proof -
from e obtain y where f: "P ∧ Q(y)" ..
from f have p: "P" ..
from f have q: "Q(y)" ..
from q have eq: "∃x. Q(x)" ..
from p eq show "P ∧ (∃x. Q(x))" ..
qed

text {*
Lema. [Ejemplo con cuantificador existencial y demostración regresiva]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))"
*}

lemma
assumes e: "∃x. P ∧ Q(x)"
shows "P ∧ (∃x. Q(x))"
proof (rule conjI)
show "P"
proof -
from e obtain y where p: "P ∧ Q(y)" by (rule exE)
from p show "P" by (rule conjunct1)
qed
show "∃x. Q(x)"
proof -
from e obtain y where p: "P ∧ Q(y)" by (rule exE)
from p have q: "Q(y)" by (rule conjunct2)
from q show "∃x. Q(x)" by (rule exI)
qed
qed

text {*
Definición. [Ejemplo de definición existencial]
El número natural x divide al número natural y si existe un natural k
tal que k×x = y. Se representa por x | y.
*}

definition divide :: "nat ⇒ nat ⇒ bool" ("_ | _" [80,80] 80) where
"x | y ≡ ∃k. k*x = y"

text {*
Ejemplo de activación automática de regla de simplificación:
La definición de divide se añade a las reglas de simplificación.
*}

declare divide_def[simp]

text {*
Lema. [Transitividad de la divisibilidad]
Sean a, b y c números naturales. Si b es divisible por a y c es
divisible por b, entonces c es divisible por a.
*}

lemma divide_trans:
fixes a b c :: "nat"
assumes ab: "a | b" and bc: "b | c"
shows "a | c"
proof simp
from ab obtain m where m: "m*a = b" by auto
from bc obtain n where n: "n*b = c" by auto
from m n have "m*n*a = c" by auto
thus "∃k. k*a = c" by (rule exI)
qed

text {*
Método auto: En el lema anterior es la primera vez que se usa el
método automático "auto".

Lema. [CNS de divisibilidad]
Sean a y b dos números naturales. Entonces a es divisible por b syss
el resto de dividir a entre b es cero.
*}

lemma CNS_divisibilidad:
"(a | b) = (b mod a = 0)"
by auto

section {* Razonamiento ecuacional *}

text {*
Elementos para el razonamiento ecuacional:
El razonamiento ecuacional se realiza de manera más concisa usando la
combinación de "also" (además) y "finally" (finalmente).

Lema. [Ejemplo de razonamiento ecuacional]
Si a=b, b=c y c=d, entonces a=d.
*}

lemma
assumes 1: "a = b" and 2: "b = c" and 3: "c = d"
shows "a = d"
proof -
have "a = b" by (rule 1)
also have "… = c" by (rule 2)
also have "… = d" by (rule 3)
finally show "a = d" .
qed

text {*
El lema anterior puede demostrarse automáticamente con la maza
("sledgehammer").
*}

lemma
assumes 1: "a = b" and 2: "b = c" and 3: "c = d"
shows "a = d"
proof -
show "a=d" by (metis 1 2 3)
qed

end
</source>

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

2012-01-31T19:08:46Z

Jalonso:

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

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

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

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

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

primrec 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 por inducción, 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 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 del teorema es la siguiente
*}

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 12: Conjuntos, funciones y relaciones

2012-01-31T19:07:29Z

Jalonso:

<source lang="isar">
header {* Tema 12: Conjuntos, funciones y relaciones *}

theory Tema_12
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

text {*
Nota. La teoría elemental de conjuntos es HOL/Set.thy.

Nota. En un conjunto todos los elemento son del mismo tipo (por
ejemplo, del tipo τ) y el conjunto tiene tipo (en el ejemplo, "τ set").

Reglas de la intersección:
· IntI: ⟦c ∈ A; c ∈ B⟧ ⟹ c ∈ A ∩ B
· IntD1: c ∈ A ∩ B ⟹ c ∈ A
· IntD2: c ∈ A ∩ B ⟹ c ∈ B

Nota. Propiedades del complementario:
· Compl_iff: (c ∈ - A) = (c ∉ A)
· Compl_Un: - (A ∪ B) = - A ∩ - B

Nota. El conjunto vacío se representa por {} y el universal por UNIV.

Nota. Propiedades de la \textbf{diferencia} y del complementario:
· Diff_disjoint: A ∩ (B - A) = {}
· Compl_partition: A ∪ - A = UNIV

Nota. Reglas de la relación de \textbf{subconjunto}:
· subsetI: (⋀x. x ∈ A ⟹ x ∈ B) ⟹ A ⊆ B
· subsetD: ⟦A ⊆ B; c ∈ A⟧ ⟹ c ∈ B

Nota. Ejemplo trivial.
*}

lemma "(A ∪ B ⊆ C) = (A ⊆ C ∧ B ⊆ C)"
by blast

text {*
Nota. Otro ejemplo trivial.
*}

lemma "(A ⊆ -B) = (B ⊆ -A)"
by blast

text {*
Principio de extensionalidad de conjuntos:
· set_ext: (⋀x. (x ∈ A) = (x ∈ B)) ⟹ A = B

Reglas de la igualdad de conjuntos:
· equalityI: ⟦A ⊆ B; B ⊆ A⟧ ⟹ A = B
· equalityE: ⟦A = B; ⟦A ⊆ B; B ⊆ A⟧ ⟹ P⟧ ⟹ P

Lema. [Analogía entre intersección y conjunción]
"x ∈ A ∩ B" syss "x ∈ A" y "x ∈ B".
*}

lemma "(x ∈ A ∩ B) = (x ∈ A ∧ x ∈ B)"
by simp

text {*
Lema. [Analogía entre unión y disyunción]
"x ∈ A ∪ B" syss "x ∈ A" ó "x ∈ B".
*}

lemma "(x ∈ A ∪ B) = (x ∈ A ∨ x ∈ B)"
by simp

text {*
Lema. [Analogía entre subconjunto e implicación]
"(A ⊆ B)" syss para todo "x", si "x ∈ A" entonces "x ∈ B".
*}

lemma "(A ⊆ B) = (∀ x. x ∈ A ⟶ x ∈ B)"
by auto

text {*
Lema. [Analogía entre complementario y negación]
x pertenece al complementario de A syss x no pertenece a A.
*}

lemma "(x ∈ -A) = (x ∉ A)"
by simp

subsection {* Notación de conjuntos finitos *}

text {*
Nota. La teoría de conjuntos finitos es HOL/Finite_Set.thy.

Nota. Los conjuntos finitos se definen por inducción a partir de las
siguientes reglas inductivas:
· El conjunto vacío es un conjunto finito.
· emptyI: "finite {}"
· Si se le añade un elemento a un conjunto finito se obtiene otro
conjunto finito.
· insertI: "finite A ⟹ finite (insert a A)"

A continuación se muestran ejemplos de conjuntos finitos.
*}

lemma
"insert 2 {} = {2} ∧
insert 3 {2} = {2,3} ∧
insert 2 {2,3} = {2,3} ∧
{2,3} = {3,2,3,2,2}"
by auto

text {*
Nota. Los conjuntos finitos se representan con la notación conjuntista
habitual: los elementos entre llaves y separados por comas.

Nota. Lema trivial.
*}

lemma "{a,b} ∪ {c,d} = {a,b,c,d}"
by blast

text {*
Nota. Conjetura falsa.
*}

lemma "{a,b} ∩ {b,c} = {b}"
refute
oops

text {*
Nota. Conjetura corregida.
*}

lemma "{a,b} ∩ {b,c} = (if a=c then {a,b} else {b})"
by auto

text {*
Sumas y productos de conjuntos finitos:
· (setsum f A) es la suma de la aplicación de f a los elementos del
conjunto finito A,
· (setprod f A) es producto de la aplicación de f a los elementos del
conjunto finito A,
· ∑A es la suma de los elementos del conjunto finito A,
· ∏A es el producto de los elementos del conjunto finito A.

Ejemplos de definiciones recursivas sobre conjuntos finitos:
Sea A un conjunto finito de números naturales.
· sumaConj A es la suma de los elementos A.
· productoConj A es el producto de los elementos de A.
· sumaCuadradosconj A es la suma de los cuadrados de los elementos A.
*}

definition sumaConj :: "nat set ⇒ nat" where
"sumaConj S ≡ ∑S"

definition productoConj :: "nat set ⇒ nat" where
"productoConj S ≡ ∏S"

definition sumaCuadradosConj :: "nat set ⇒ nat" where
"sumaCuadradosConj S ≡ setsum (λx. x*x) S"

text {*
Nota. Para simplificar lo que sigue, declaramos las anteriores
definiciones como reglas de simplificación.
*}

declare sumaConj_def[simp]
declare productoConj_def[simp]
declare sumaCuadradosConj_def[simp]

text {*
Ejemplos de evaluación de las anteriores definiciones recursivas.
*}

lemma
"sumaConj {1,2,3,4} = 10 ∧
productoConj {1,2,3} = productoConj {3,2} ∧
sumaCuadradosConj {1,2,3,4} = 30"
by simp

text {*
Inducción sobre conjuntos finitos: Para demostrar que todos los
conjuntos finitos tienen una propiedad P basta probar que
· El conjunto vacío tiene la propiedad P.
· Si a un conjunto finito que tiene la propiedad P se le añade un nuevo
elemento, el conjunto obtenido sigue teniendo la propiedad P.
En forma de regla
· finite_induct: ⟦finite F;
P {};
⋀x F. ⟦finite F; x ∉ F; P F⟧ ⟹ P ({x} ∪ F)⟧
⟹ P F

Lema. [Ejemplo de inducción sobre conjuntos finitos]
Sea S un conjunto finito de números naturales. Entonces todos los
elementos de S son menores o iguales que la suma de los elementos de S.

Demostración automática:
*}

lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
by (induct rule: finite_induct) auto

text {*
Demostración estructurada:
*}

lemma sumaConj_acota: "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
proof (induct rule: finite_induct)
show "∀x∈{}. x ≤ sumaConj {}" by simp
next
fix x and F
assume fF: "finite F"
and xF: "x ∉ F"
and HI: "∀ x∈F. x ≤ sumaConj F"
show "∀y∈insert x F. y ≤ sumaConj (insert x F)"
proof
fix y
assume "y ∈ insert x F"
show "y ≤ sumaConj (insert x F)"
proof (cases "y = x")
assume "y = x"
hence "y ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
next
assume "y ≠ x"
hence "y ∈ F" using `y ∈ insert x F` by simp
hence "y ≤ sumaConj F" using HI by blast
also have "… ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
qed
qed
qed

subsection {* Definiciones por comprensión *}

text {*
El conjunto de los elementos que cumple la propiedad P se representa
por {x. P}.

Reglas de comprensión (relación entre colección y pertenencia):
· mem_Collect_eq: (a ∈ {x. P x}) = P a
· Collect_mem_eq: {x. x ∈ A} = A

Dos lemas triviales.
*}

lemma "{x. P x ∨ x ∈ A} = {x. P x} ∪ A"
by blast

lemma "{x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}"
by blast

text {*
Nota. Ejemplo con la sintaxis general de comprensión.
*}

lemma
"{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}"
by blast

text {*
En HOL, la notación conjuntista es azúcar sintáctica:
· x ∈ A es equivalente a A(x).
· {x. P} es equivalente a λx. P.
*}

text {*
Definición. [Ejemplo de definición por comprensión]
El conjunto de los pares es el de los números n para los que existe un
m tal que n = 2*m.
*}

definition Pares :: "nat set" where
"Pares ≡ {n. ∃ m. n = 2*m }"

text {*
Ejemplo. Los números 2 y 34 son pares.
*}

lemma
"2 ∈ Pares ∧
34 ∈ Pares"
by (simp add: Pares_def)

text {*
Definición. El conjunto de los impares es el de los números n para los
que existe un m tal que n = 2*m + 1.
*}

definition Impares :: "nat set" where
"Impares ≡ {n. ∃ m. n = 2*m + 1 }"

text {*
Lema. [Ejemplo con las reglas de intersección y comprensión]
El conjunto de los pares es disjunto con el de los impares.
*}

lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" by (rule IntD1)
hence "∃ m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..

from S have "x ∈ Impares" by (rule IntD2)
hence "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..

from p and q show "False" by arith
qed

subsection {* Cuantificadores acotados *}

text {*
Reglas de cuantificador universal acotado ("bounded"):
· ballI: (⋀x. x ∈ A ⟹ P x) ⟹ ∀x∈A. P x
· bspec: ⟦∀x∈A. P x; x ∈ A⟧ ⟹ P x

Reglas de cuantificador existencial acotado ("bounded"):
· bexI: ⟦P x; x ∈ A⟧ ⟹ ∃x∈A. P x
· bexE: ⟦∃x∈A. P x; ⋀x. ⟦x ∈ A; P x⟧ ⟹ Q⟧ ⟹ Q

Reglas de la unión indexada:
· UN_iff: (b ∈ (⋃x∈A. B x)) = (∃x∈A. b ∈ B x)
· UN_I: ⟦a ∈ A; b ∈ B a⟧ ⟹ b ∈ (⋃x∈A. B x)
· UN_E: ⟦b ∈ (⋃x∈A. B x); ⋀x. ⟦x ∈ A; b ∈ B x⟧ ⟹ R⟧ ⟹ R

Reglas de la unión de una familia:
· Union_def: ⋃S = (⋃x∈S. x)
· Union_iff: (A ∈ ⋃C) = (∃X∈C. A ∈ X)

Reglas de la intersección indexada:
· INT_iff: (b ∈ (⋂x∈A. B x)) = (∀x∈A. b ∈ B x)
· INT_I: (⋀x. x ∈ A ⟹ b ∈ B x) ⟹ b ∈ (⋂x∈A. B x)
· INT_E: ⟦b ∈ (⋂x∈A. B x); b ∈ B a ⟹ R; a ∉ A ⟹ R⟧ ⟹ R

Reglas de la intersección de una familia:
· Inter_def: ⋂S = (⋂x∈S. x)
· Inter_iff: (A ∈ ⋂C) = (∀X∈C. A ∈ X)

Abreviaturas:
· "Collect P" es lo mismo que "{x. P}".
· "All P" es lo mismo que "∀x. P x".
· "Ex P" es lo mismo que "∃x. P x".
· "Ball P" es lo mismo que "∀x∈A. P x".
· "Bex P" es lo mismo que "∃x∈A. P x".
*}

subsection {* Conjuntos finitos y cardinalidad *}

text {*
El número de elementos de un conjunto finito A es el cardinal de A y se
representa por "card A".

Ejemplos de cardinales de conjuntos finitos.
*}

lemma
"card {} = 0 ∧
card {4} = 1 ∧
card {4,1} = 2 ∧
x ≠ y ⟹ card {x,y} = 2"
by simp

text {*
Propiedades de cardinales:
· Cardinal de la unión de conjuntos finitos:
card_Un_Int: ⟦finite A; finite B⟧
⟹ card A + card B = card (A ∪ B) + card (A ∩ B)"
· Cardinal del conjunto potencia:
card_Pow: finite A ⟹ card (Pow A) = 2 ^ card A
*}

section {* Funciones *}

text {*
La teoría de funciones es HOL/Fun.thy.
*}

subsection {* Nociones básicas de funciones *}

text {*
Principio de extensionalidad para funciones:
· ext: (⋀x. f x = g x) ⟹ f = g

Actualización de funciones
· fun_upd_apply: (f(x := y)) z = (if z = x then y else f z)
· fun_upd_upd: f(x := y, x := z) = f(x := z)

Función identidad
· id_def: id ≡ λx. x

Composición de funciones:
· o_def: f ∘ g = (λx. f (g x))

Asociatividad de la composición:
· o_assoc: f ∘ (g ∘ h) = (f ∘ g) ∘ h
*}

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

text {*
Función inyectiva sobre A:
· inj_on_def: inj_on f A ≡ ∀x∈A. ∀y∈A. f x = f y ⟶ x = y

Nota. "inj f" es una abreviatura de "inj_on f UNIV".

Función suprayectiva:
· surj_def: surj f ≡ ∀y. ∃x. y = f x

Función biyectiva:
· bij_def: bij f ≡ inj f ∧ surj f

Propiedades de las funciones inversas:
· inv_f_f: inj f ⟹ inv f (f x) = x
· surj_f_inv_f: surj f ⟹ f (inv f y) = y
· inv_inv_eq: bij f ⟹ inv (inv f) = f

Igualdad de funciones (por extensionalidad):
· fun_eq_iff: (f = g) = (∀x. f x = g x)

Lema. Una función inyectiva puede cancelarse en el lado izquierdo de
la composición de funciones.
*}

lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
thus "g = h" using `inj f` by (simp add:fun_eq_iff inj_on_def)
next
assume "g = h"
thus "f ∘ g = f ∘ h" by auto
qed

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

lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
show "g = h"
proof
fix x
have "(f ∘ g)(x) = (f ∘ h)(x)" using `f ∘ g = f ∘ h` by simp
hence "f(g(x)) = f(h(x))" by simp
thus "g(x) = h(x)" using `inj f` by (simp add:inj_on_def)
qed
next
assume "g = h"
show "f ∘ g = f ∘ h"
proof
fix x
have "(f ∘ g) x = f(g(x))" by simp
also have "… = f(h(x))" using `g = h` by simp
also have "… = (f ∘ h) x" by simp
finally show "(f ∘ g) x = (f ∘ h) x" by simp
qed
qed

subsubsection {* Función imagen *}

text {*
Imagen de un conjunto mediante una función:
· image_def: f ` A = {y. (∃x∈A. y = f x)

Propiedades de la imagen:
· image_compose: (f ∘ g)`r = f`g`r
· image_Un: f`(A ∪ B) = f`A ∪ f`B
· image_Int: inj f ⟹ f`(A ∩ B) = f`A ∩ f`B"

Ejemplos de demostraciones triviales de propiedades de la imagen.
*}

lemma "f`A ∪ g`A = (⋃x∈A. {f x, g x})"
by auto

lemma "f`{(x,y). P x y} = {f(x,y) | x y. P x y}"
by auto

text {*
El rango de una función ("range f") es la imagen del universo ("f`UNIV").

Imagen inversa de un conjunto:
· vimage_def: f -` B ≡ {x. f x : B}

Propiedad de la imagen inversa de un conjunto:
· vimage_Compl: f -` (-A) = -(f -` A)
*}

section {* Relaciones *}

subsection {* Relaciones básicas *}

text {*
La teoría de relaciones es HOL/Relation.thy.

Las relaciones son conjuntos de pares.

Relación identidad:
· Id_def: Id ≡ {p. ∃x. p = (x,x)}

Composición de relaciones:
· rel_comp_def: r O s ≡ {(x,z). EX y. (x, y) ∈ r & (y, z) ∈ s}

Propiedades:
· R_O_Id: R O Id = R
· rel_comp_mono: ⟦r' ⊆ r; s' ⊆ s⟧ ⟹ (r' O s') ⊆ (r O s)

Imagen inversa de una relación:
· converse_iff: ((a,b) ∈ r\<^bsup>\<^sup>-1\<^esup>) = ((b,a) ∈ r)

Propiedad de la imagen inversa de una relación:
· converse_rel_comp: (r O s)\<^bsup>-1\<^esup> = s\<^bsup>-1\<^esup> O r\<^bsup>-1\<^esup>

Imagen de un conjunto mediante una relación:
· Image_iff: (b ∈ r``A) = (∃x:A. (x, b) ∈ r)

Dominio de una relación:
· Domain_iff: (a ∈ Domain r) = (∃y. (a, y) ∈ r)

Rango de una relación:
· Range_iff: (a ∈ Range r) = (∃y. (y,a) ∈ r)
*}

subsection {* Clausura reflexiva y transitiva *}

text {*
La teoría de la clausura reflexiva y transitiva de una relación es
HOL/Transitive_Closure.thy.

Potencias de relaciones:
· R ^^ 0 = Id
· R ^^ (Suc n) = (R ^^ n) O R

La clausura reflexiva y transitiva de la relación r es la menor
solución de la ecuación:
· rtrancl_unfold: r\<^sup>* = Id ∪ (r\<^sup>* O r)

Propiedades básicas de la clausura reflexiva y transitiva:
· rtrancl_refl: (a, a) ∈ r\<^sup>*
· r_into_rtrancl: p ∈ r ⟹ p ∈ r\<^sup>*
· rtrancl_trans: ⟦(a, b) ∈ r\<^sup>*; (b, c) ∈ r\<^sup>*⟧ ⟹ (a, c) ∈ r\<^sup>*

Inducción sobre la clausura reflexiva y transitiva
· rtrancl_induct: ⟦(a,b) ∈ r\<^sup>*;
P b;
⋀y z. ⟦(y, z) ∈ r; (z, b) ∈ r\<^sup>*; P z⟧ ⟹ P y⟧
⟹ P a"}

Idempotencia de la clausura reflexiva y transitiva:
· rtrancl_idemp: (r\<^sup>* )\<^sup>* = r\<^sup>*

Reglas de introducción de la clausura transitiva:
· r_into_trancl': p ∈ r ⟹ p ∈ r\<^sup>+
· trancl_trans: ⟦(a, b) ∈ r\<^sup>+; (b, c) ∈ r\<^sup>+⟧ ⟹ (a, c) ∈ r\<^sup>+

Ejemplo de propiedad:
· trancl\_converse: (r¯¹)\<^sup>+ = (r\<^sup>+)¯¹
*}

subsection {* Una demostración elemental *}

text {*
El teorema que se desea demostrar es que la clausura reflexiva y
transitiva conmuta con la inversa (rtrancl_converse). Para
demostrarlo introducimos dos lemas auxiliares: rtrancl_converseD y
rtrancl_converseI.
*}

lemma rtrancl_converseD: "(x,y) ∈ (r¯¹)\<^sup>* ⟹ (y,x) ∈ r\<^sup>*"
proof (induct rule:rtrancl_induct)
show "(x,x) ∈ r\<^sup>*" by (rule rtrancl_refl)
next
fix y z
assume "(x,y) ∈ (r¯¹)\<^sup>*" and "(y,z) ∈ r¯¹" and "(y,x) ∈ r\<^sup>*"
show "(z,x) ∈ r\<^sup>*"
proof (rule rtrancl_trans)
show "(z,y) ∈ r\<^sup>*" using `(y,z) ∈ r¯¹` by simp
next
show "(y,x) ∈ r\<^sup>*" using `(y,x) ∈ r\<^sup>*` by simp
qed
qed

lemma rtrancl_converseI: "(y,x) ∈ r\<^sup>* ⟹ (x,y) ∈ (r¯¹)\<^sup>*"
proof (induct rule:rtrancl_induct)
show "(y,y) ∈ (r¯¹)\<^sup>*" by (rule rtrancl_refl)
next
fix u z
assume "(y,u) ∈ r\<^sup>*" and "(u,z) ∈ r" and "(u,y) ∈ (r¯¹)\<^sup>*"
show "(z,y) ∈ (r¯¹)\<^sup>*"
proof (rule rtrancl_trans)
show "(z,u) ∈ (r¯¹)\<^sup>*" using `(u,z) ∈ r` by auto
next
show "(u,y) ∈ (r¯¹)\<^sup>*" using `(u,y) ∈ (r¯¹)\<^sup>*` by simp
qed
qed

theorem rtrancl_converse: "(r¯¹)\<^sup>* = (r\<^sup>*)¯¹"
proof
show "(r¯¹)\<^sup>* ⊆ (r\<^sup>*)¯¹" by (auto simp add:rtrancl_converseD)
next
show "(r\<^sup>*)¯¹ ⊆ (r¯¹)\<^sup>*" by (auto simp add:rtrancl_converseI)
qed

text {*
Puede demostrarse de manera más corta como sigue:
*}

theorem "(r¯¹)\<^sup>* = (r\<^sup>*)¯¹"
by (auto intro: rtrancl_converseI dest: rtrancl_converseD)

section {* Relaciones bien fundamentadas e inducción *}

text {*
La teoría de las relaciones bien fundamentadas es
HOL/Wellfounded_Relations.thy.

La relación-objeto "less_than" es el orden de los naturales que es
bien fundamentada:
· less_than_iff: ((x,y) ∈ less_than) = (x < y)
· wf_less_than: wf less_than

Notas sobre medidas:
· Imagen inversa de una relación mediante una función:
· inv_image_def: inv_image r f ≡ {(x,y). (f x,f y) ∈ r
· Conservación de la buena fundamentación:\\
· wf_inv_image: wf r ⟹ wf (inv_image r f)
· Definición de la \textbf{medida}:\\
· measure_def: measure ≡ inv_image less_than
· Buena fundamentación de la medida:\\
· wf_measure: wf (measure f)
*}

text {*
Notas sobre el producto lexicográfico:
· Definición del producto lexicográfico (lex_prod_def)":
ra <*lex*> rb ≡ {((a,b),(a',b')). (a,a') ∈ ra ∨
(a = a' ∧ (b,b') ∈ rb)}
· Conservación de la buena fundamentación:
· wf_lex_prod: ⟦wf ra; wf rb⟧ ⟹ wf (ra <*lex*> rb)

El orden de multiconjuntos está en la teoría HOL/Library/Multiset.thy.

Inducción sobre relaciones bien fundamentadas:
· wf_induct: ⟦wf r; ⋀x. (⋀y. (y,x) ∈ r ⟹ P y) ⟹ P x⟧ ⟹ P a
*}

end
</source>

Tema 12: Conjuntos, funciones y relaciones

2012-01-31T19:06:28Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 12: Conjuntos, funciones y relaciones *} theory Tema_12 imports Main begin section {* Conjuntos *} subsection {* Operaciones con conjunto...'

<source lang="isar">
header {* Tema 12: Conjuntos, funciones y relaciones *}

theory Tema_12
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

text {*
Nota. La teoría elemental de conjuntos es HOL/Set.thy.

Nota. En un conjunto todos los elemento son del mismo tipo (por
ejemplo, del tipo \<tau>) y el conjunto tiene tipo (en el ejemplo, "\<tau> set").

Reglas de la intersección:
· IntI: \<lbrakk>c \<in> A; c \<in> B\<rbrakk> \<Longrightarrow> c \<in> A \<inter> B
· IntD1: c \<in> A \<inter> B \<Longrightarrow> c \<in> A
· IntD2: c \<in> A \<inter> B \<Longrightarrow> c \<in> B

Nota. Propiedades del complementario:
· Compl_iff: (c \<in> - A) = (c \<notin> A)
· Compl_Un: - (A \<union> B) = - A \<inter> - B

Nota. El conjunto vacío se representa por {} y el universal por UNIV.

Nota. Propiedades de la \textbf{diferencia} y del complementario:
· Diff_disjoint: A \<inter> (B - A) = {}
· Compl_partition: A \<union> - A = UNIV

Nota. Reglas de la relación de \textbf{subconjunto}:
· subsetI: (\<And>x. x \<in> A \<Longrightarrow> x \<in> B) \<Longrightarrow> A \<subseteq> B
· subsetD: \<lbrakk>A \<subseteq> B; c \<in> A\<rbrakk> \<Longrightarrow> c \<in> B

Nota. Ejemplo trivial.
*}

lemma "(A \<union> B \<subseteq> C) = (A \<subseteq> C \<and> B \<subseteq> C)"
by blast

text {*
Nota. Otro ejemplo trivial.
*}

lemma "(A \<subseteq> -B) = (B \<subseteq> -A)"
by blast

text {*
Principio de extensionalidad de conjuntos:
· set_ext: (\<And>x. (x \<in> A) = (x \<in> B)) \<Longrightarrow> A = B

Reglas de la igualdad de conjuntos:
· equalityI: \<lbrakk>A \<subseteq> B; B \<subseteq> A\<rbrakk> \<Longrightarrow> A = B
· equalityE: \<lbrakk>A = B; \<lbrakk>A \<subseteq> B; B \<subseteq> A\<rbrakk> \<Longrightarrow> P\<rbrakk> \<Longrightarrow> P

Lema. [Analogía entre intersección y conjunción]
"x \<in> A \<inter> B" syss "x \<in> A" y "x \<in> B".
*}

lemma "(x \<in> A \<inter> B) = (x \<in> A \<and> x \<in> B)"
by simp

text {*
Lema. [Analogía entre unión y disyunción]
"x \<in> A \<union> B" syss "x \<in> A" ó "x \<in> B".
*}

lemma "(x \<in> A \<union> B) = (x \<in> A \<or> x \<in> B)"
by simp

text {*
Lema. [Analogía entre subconjunto e implicación]
"(A \<subseteq> B)" syss para todo "x", si "x \<in> A" entonces "x \<in> B".
*}

lemma "(A \<subseteq> B) = (\<forall> x. x \<in> A \<longrightarrow> x \<in> B)"
by auto

text {*
Lema. [Analogía entre complementario y negación]
x pertenece al complementario de A syss x no pertenece a A.
*}

lemma "(x \<in> -A) = (x \<notin> A)"
by simp

subsection {* Notación de conjuntos finitos *}

text {*
Nota. La teoría de conjuntos finitos es HOL/Finite_Set.thy.

Nota. Los conjuntos finitos se definen por inducción a partir de las
siguientes reglas inductivas:
· El conjunto vacío es un conjunto finito.
· emptyI: "finite {}"
· Si se le añade un elemento a un conjunto finito se obtiene otro
conjunto finito.
· insertI: "finite A \<Longrightarrow> finite (insert a A)"

A continuación se muestran ejemplos de conjuntos finitos.
*}

lemma
"insert 2 {} = {2} \<and>
insert 3 {2} = {2,3} \<and>
insert 2 {2,3} = {2,3} \<and>
{2,3} = {3,2,3,2,2}"
by auto

text {*
Nota. Los conjuntos finitos se representan con la notación conjuntista
habitual: los elementos entre llaves y separados por comas.

Nota. Lema trivial.
*}

lemma "{a,b} \<union> {c,d} = {a,b,c,d}"
by blast

text {*
Nota. Conjetura falsa.
*}

lemma "{a,b} \<inter> {b,c} = {b}"
refute
oops

text {*
Nota. Conjetura corregida.
*}

lemma "{a,b} \<inter> {b,c} = (if a=c then {a,b} else {b})"
by auto

text {*
Sumas y productos de conjuntos finitos:
· (setsum f A) es la suma de la aplicación de f a los elementos del
conjunto finito A,
· (setprod f A) es producto de la aplicación de f a los elementos del
conjunto finito A,
· \<Sum>A es la suma de los elementos del conjunto finito A,
· \<Prod>A es el producto de los elementos del conjunto finito A.

Ejemplos de definiciones recursivas sobre conjuntos finitos:
Sea A un conjunto finito de números naturales.
· sumaConj A es la suma de los elementos A.
· productoConj A es el producto de los elementos de A.
· sumaCuadradosconj A es la suma de los cuadrados de los elementos A.
*}

definition sumaConj :: "nat set \<Rightarrow> nat" where
"sumaConj S \<equiv> \<Sum>S"

definition productoConj :: "nat set \<Rightarrow> nat" where
"productoConj S \<equiv> \<Prod>S"

definition sumaCuadradosConj :: "nat set \<Rightarrow> nat" where
"sumaCuadradosConj S \<equiv> setsum (\<lambda>x. x*x) S"

text {*
Nota. Para simplificar lo que sigue, declaramos las anteriores
definiciones como reglas de simplificación.
*}

declare sumaConj_def[simp]
declare productoConj_def[simp]
declare sumaCuadradosConj_def[simp]

text {*
Ejemplos de evaluación de las anteriores definiciones recursivas.
*}

lemma
"sumaConj {1,2,3,4} = 10 \<and>
productoConj {1,2,3} = productoConj {3,2} \<and>
sumaCuadradosConj {1,2,3,4} = 30"
by simp

text {*
Inducción sobre conjuntos finitos: Para demostrar que todos los
conjuntos finitos tienen una propiedad P basta probar que
· El conjunto vacío tiene la propiedad P.
· Si a un conjunto finito que tiene la propiedad P se le añade un nuevo
elemento, el conjunto obtenido sigue teniendo la propiedad P.
En forma de regla
· finite_induct: \<lbrakk>finite F;
P {};
\<And>x F. \<lbrakk>finite F; x \<notin> F; P F\<rbrakk> \<Longrightarrow> P ({x} \<union> F)\<rbrakk>
\<Longrightarrow> P F

Lema. [Ejemplo de inducción sobre conjuntos finitos]
Sea S un conjunto finito de números naturales. Entonces todos los
elementos de S son menores o iguales que la suma de los elementos de S.

Demostración automática:
*}

lemma "finite S \<Longrightarrow> \<forall>x\<in>S. x \<le> sumaConj S"
by (induct rule: finite_induct) auto

text {*
Demostración estructurada:
*}

lemma sumaConj_acota: "finite S \<Longrightarrow> \<forall>x\<in>S. x \<le> sumaConj S"
proof (induct rule: finite_induct)
show "\<forall>x\<in>{}. x \<le> sumaConj {}" by simp
next
fix x and F
assume fF: "finite F"
and xF: "x \<notin> F"
and HI: "\<forall> x\<in>F. x \<le> sumaConj F"
show "\<forall>y\<in>insert x F. y \<le> sumaConj (insert x F)"
proof
fix y
assume "y \<in> insert x F"
show "y \<le> sumaConj (insert x F)"
proof (cases "y = x")
assume "y = x"
hence "y \<le> x + (sumaConj F)" by simp
also have "\<dots> = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
next
assume "y \<noteq> x"
hence "y \<in> F" using `y \<in> insert x F` by simp
hence "y \<le> sumaConj F" using HI by blast
also have "\<dots> \<le> x + (sumaConj F)" by simp
also have "\<dots> = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
qed
qed
qed

subsection {* Definiciones por comprensión *}

text {*
El conjunto de los elementos que cumple la propiedad P se representa
por {x. P}.

Reglas de comprensión (relación entre colección y pertenencia):
· mem_Collect_eq: (a \<in> {x. P x}) = P a
· Collect_mem_eq: {x. x \<in> A} = A

Dos lemas triviales.
*}

lemma "{x. P x \<or> x \<in> A} = {x. P x} \<union> A"
by blast

lemma "{x. P x \<longrightarrow> Q x} = -{x. P x} \<union> {x. Q x}"
by blast

text {*
Nota. Ejemplo con la sintaxis general de comprensión.
*}

lemma
"{p*q | p q. p \<in> prime \<and> q \<in> prime} =
{z. \<exists>p q. z = p*q \<and> p \<in> prime \<and> q \<in> prime}"
by blast

text {*
En HOL, la notación conjuntista es azúcar sintáctica:
· x \<in> A es equivalente a A(x).
· {x. P} es equivalente a \<lambda>x. P.
*}

text {*
Definición. [Ejemplo de definición por comprensión]
El conjunto de los pares es el de los números n para los que existe un
m tal que n = 2*m.
*}

definition Pares :: "nat set" where
"Pares \<equiv> {n. \<exists> m. n = 2*m }"

text {*
Ejemplo. Los números 2 y 34 son pares.
*}

lemma
"2 \<in> Pares \<and>
34 \<in> Pares"
by (simp add: Pares_def)

text {*
Definición. El conjunto de los impares es el de los números n para los
que existe un m tal que n = 2*m + 1.
*}

definition Impares :: "nat set" where
"Impares \<equiv> {n. \<exists> m. n = 2*m + 1 }"

text {*
Lema. [Ejemplo con las reglas de intersección y comprensión]
El conjunto de los pares es disjunto con el de los impares.
*}

lemma "x \<notin> (Pares \<inter> Impares)"
proof
fix x assume S: "x \<in> (Pares \<inter> Impares)"
hence "x \<in> Pares" by (rule IntD1)
hence "\<exists> m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..

from S have "x \<in> Impares" by (rule IntD2)
hence "\<exists> m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..

from p and q show "False" by arith
qed

subsection {* Cuantificadores acotados *}

text {*
Reglas de cuantificador universal acotado ("bounded"):
· ballI: (\<And>x. x \<in> A \<Longrightarrow> P x) \<Longrightarrow> \<forall>x\<in>A. P x
· bspec: \<lbrakk>\<forall>x\<in>A. P x; x \<in> A\<rbrakk> \<Longrightarrow> P x

Reglas de cuantificador existencial acotado ("bounded"):
· bexI: \<lbrakk>P x; x \<in> A\<rbrakk> \<Longrightarrow> \<exists>x\<in>A. P x
· bexE: \<lbrakk>\<exists>x\<in>A. P x; \<And>x. \<lbrakk>x \<in> A; P x\<rbrakk> \<Longrightarrow> Q\<rbrakk> \<Longrightarrow> Q

Reglas de la unión indexada:
· UN_iff: (b \<in> (\<Union>x\<in>A. B x)) = (\<exists>x\<in>A. b \<in> B x)
· UN_I: \<lbrakk>a \<in> A; b \<in> B a\<rbrakk> \<Longrightarrow> b \<in> (\<Union>x\<in>A. B x)
· UN_E: \<lbrakk>b \<in> (\<Union>x\<in>A. B x); \<And>x. \<lbrakk>x \<in> A; b \<in> B x\<rbrakk> \<Longrightarrow> R\<rbrakk> \<Longrightarrow> R

Reglas de la unión de una familia:
· Union_def: \<Union>S = (\<Union>x\<in>S. x)
· Union_iff: (A \<in> \<Union>C) = (\<exists>X\<in>C. A \<in> X)

Reglas de la intersección indexada:
· INT_iff: (b \<in> (\<Inter>x\<in>A. B x)) = (\<forall>x\<in>A. b \<in> B x)
· INT_I: (\<And>x. x \<in> A \<Longrightarrow> b \<in> B x) \<Longrightarrow> b \<in> (\<Inter>x\<in>A. B x)
· INT_E: \<lbrakk>b \<in> (\<Inter>x\<in>A. B x); b \<in> B a \<Longrightarrow> R; a \<notin> A \<Longrightarrow> R\<rbrakk> \<Longrightarrow> R

Reglas de la intersección de una familia:
· Inter_def: \<Inter>S = (\<Inter>x\<in>S. x)
· Inter_iff: (A \<in> \<Inter>C) = (\<forall>X\<in>C. A \<in> X)

Abreviaturas:
· "Collect P" es lo mismo que "{x. P}".
· "All P" es lo mismo que "\<forall>x. P x".
· "Ex P" es lo mismo que "\<exists>x. P x".
· "Ball P" es lo mismo que "\<forall>x\<in>A. P x".
· "Bex P" es lo mismo que "\<exists>x\<in>A. P x".
*}

subsection {* Conjuntos finitos y cardinalidad *}

text {*
El número de elementos de un conjunto finito A es el cardinal de A y se
representa por "card A".

Ejemplos de cardinales de conjuntos finitos.
*}

lemma
"card {} = 0 \<and>
card {4} = 1 \<and>
card {4,1} = 2 \<and>
x \<noteq> y \<Longrightarrow> card {x,y} = 2"
by simp

text {*
Propiedades de cardinales:
· Cardinal de la unión de conjuntos finitos:
card_Un_Int: \<lbrakk>finite A; finite B\<rbrakk>
\<Longrightarrow> card A + card B = card (A \<union> B) + card (A \<inter> B)"
· Cardinal del conjunto potencia:
card_Pow: finite A \<Longrightarrow> card (Pow A) = 2 ^ card A
*}

section {* Funciones *}

text {*
La teoría de funciones es HOL/Fun.thy.
*}

subsection {* Nociones básicas de funciones *}

text {*
Principio de extensionalidad para funciones:
· ext: (\<And>x. f x = g x) \<Longrightarrow> f = g

Actualización de funciones
· fun_upd_apply: (f(x := y)) z = (if z = x then y else f z)
· fun_upd_upd: f(x := y, x := z) = f(x := z)

Función identidad
· id_def: id \<equiv> \<lambda>x. x

Composición de funciones:
· o_def: f \<circ> g = (\<lambda>x. f (g x))

Asociatividad de la composición:
· o_assoc: f \<circ> (g \<circ> h) = (f \<circ> g) \<circ> h
*}

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

text {*
Función inyectiva sobre A:
· inj_on_def: inj_on f A \<equiv> \<forall>x\<in>A. \<forall>y\<in>A. f x = f y \<longrightarrow> x = y

Nota. "inj f" es una abreviatura de "inj_on f UNIV".

Función suprayectiva:
· surj_def: surj f \<equiv> \<forall>y. \<exists>x. y = f x

Función biyectiva:
· bij_def: bij f \<equiv> inj f \<and> surj f

Propiedades de las funciones inversas:
· inv_f_f: inj f \<Longrightarrow> inv f (f x) = x
· surj_f_inv_f: surj f \<Longrightarrow> f (inv f y) = y
· inv_inv_eq: bij f \<Longrightarrow> inv (inv f) = f

Igualdad de funciones (por extensionalidad):
· fun_eq_iff: (f = g) = (\<forall>x. f x = g x)

Lema. Una función inyectiva puede cancelarse en el lado izquierdo de
la composición de funciones.
*}

lemma
assumes "inj f"
shows "(f \<circ> g = f \<circ> h) = (g = h)"
proof
assume "f \<circ> g = f \<circ> h"
thus "g = h" using `inj f` by (simp add:fun_eq_iff inj_on_def)
next
assume "g = h"
thus "f \<circ> g = f \<circ> h" by auto
qed

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

lemma
assumes "inj f"
shows "(f \<circ> g = f \<circ> h) = (g = h)"
proof
assume "f \<circ> g = f \<circ> h"
show "g = h"
proof
fix x
have "(f \<circ> g)(x) = (f \<circ> h)(x)" using `f \<circ> g = f \<circ> h` by simp
hence "f(g(x)) = f(h(x))" by simp
thus "g(x) = h(x)" using `inj f` by (simp add:inj_on_def)
qed
next
assume "g = h"
show "f \<circ> g = f \<circ> h"
proof
fix x
have "(f \<circ> g) x = f(g(x))" by simp
also have "\<dots> = f(h(x))" using `g = h` by simp
also have "\<dots> = (f \<circ> h) x" by simp
finally show "(f \<circ> g) x = (f \<circ> h) x" by simp
qed
qed

subsubsection {* Función imagen *}

text {*
Imagen de un conjunto mediante una función:
· image_def: f ` A = {y. (\<exists>x\<in>A. y = f x)

Propiedades de la imagen:
· image_compose: (f \<circ> g)`r = f`g`r
· image_Un: f`(A \<union> B) = f`A \<union> f`B
· image_Int: inj f \<Longrightarrow> f`(A \<inter> B) = f`A \<inter> f`B"

Ejemplos de demostraciones triviales de propiedades de la imagen.
*}

lemma "f`A \<union> g`A = (\<Union>x\<in>A. {f x, g x})"
by auto

lemma "f`{(x,y). P x y} = {f(x,y) | x y. P x y}"
by auto

text {*
El rango de una función ("range f") es la imagen del universo ("f`UNIV").

Imagen inversa de un conjunto:
· vimage_def: f -` B \<equiv> {x. f x : B}

Propiedad de la imagen inversa de un conjunto:
· vimage_Compl: f -` (-A) = -(f -` A)
*}

section {* Relaciones *}

subsection {* Relaciones básicas *}

text {*
La teoría de relaciones es HOL/Relation.thy.

Las relaciones son conjuntos de pares.

Relación identidad:
· Id_def: Id \<equiv> {p. \<exists>x. p = (x,x)}

Composición de relaciones:
· rel_comp_def: r O s \<equiv> {(x,z). EX y. (x, y) \<in> r & (y, z) \<in> s}

Propiedades:
· R_O_Id: R O Id = R
· rel_comp_mono: \<lbrakk>r' \<subseteq> r; s' \<subseteq> s\<rbrakk> \<Longrightarrow> (r' O s') \<subseteq> (r O s)

Imagen inversa de una relación:
· converse_iff: ((a,b) \<in> r\<^bsup>\<^sup>-1\<^esup>) = ((b,a) \<in> r)

Propiedad de la imagen inversa de una relación:
· converse_rel_comp: (r O s)\<^bsup>-1\<^esup> = s\<^bsup>-1\<^esup> O r\<^bsup>-1\<^esup>

Imagen de un conjunto mediante una relación:
· Image_iff: (b \<in> r``A) = (\<exists>x:A. (x, b) \<in> r)

Dominio de una relación:
· Domain_iff: (a \<in> Domain r) = (\<exists>y. (a, y) \<in> r)

Rango de una relación:
· Range_iff: (a \<in> Range r) = (\<exists>y. (y,a) \<in> r)
*}

subsection {* Clausura reflexiva y transitiva *}

text {*
La teoría de la clausura reflexiva y transitiva de una relación es
HOL/Transitive_Closure.thy.

Potencias de relaciones:
· R ^^ 0 = Id
· R ^^ (Suc n) = (R ^^ n) O R

La clausura reflexiva y transitiva de la relación r es la menor
solución de la ecuación:
· rtrancl_unfold: r\<^sup>* = Id \<union> (r\<^sup>* O r)

Propiedades básicas de la clausura reflexiva y transitiva:
· rtrancl_refl: (a, a) \<in> r\<^sup>*
· r_into_rtrancl: p \<in> r \<Longrightarrow> p \<in> r\<^sup>*
· rtrancl_trans: \<lbrakk>(a, b) \<in> r\<^sup>*; (b, c) \<in> r\<^sup>*\<rbrakk> \<Longrightarrow> (a, c) \<in> r\<^sup>*

Inducción sobre la clausura reflexiva y transitiva
· rtrancl_induct: \<lbrakk>(a,b) \<in> r\<^sup>*;
P b;
\<And>y z. \<lbrakk>(y, z) \<in> r; (z, b) \<in> r\<^sup>*; P z\<rbrakk> \<Longrightarrow> P y\<rbrakk>
\<Longrightarrow> P a"}

Idempotencia de la clausura reflexiva y transitiva:
· rtrancl_idemp: (r\<^sup>* )\<^sup>* = r\<^sup>*

Reglas de introducción de la clausura transitiva:
· r_into_trancl': p \<in> r \<Longrightarrow> p \<in> r\<^sup>+
· trancl_trans: \<lbrakk>(a, b) \<in> r\<^sup>+; (b, c) \<in> r\<^sup>+\<rbrakk> \<Longrightarrow> (a, c) \<in> r\<^sup>+

Ejemplo de propiedad:
· trancl\_converse: (r\<inverse>)\<^sup>+ = (r\<^sup>+)\<inverse>
*}

subsection {* Una demostración elemental *}

text {*
El teorema que se desea demostrar es que la clausura reflexiva y
transitiva conmuta con la inversa (rtrancl_converse). Para
demostrarlo introducimos dos lemas auxiliares: rtrancl_converseD y
rtrancl_converseI.
*}

lemma rtrancl_converseD: "(x,y) \<in> (r\<inverse>)\<^sup>* \<Longrightarrow> (y,x) \<in> r\<^sup>*"
proof (induct rule:rtrancl_induct)
show "(x,x) \<in> r\<^sup>*" by (rule rtrancl_refl)
next
fix y z
assume "(x,y) \<in> (r\<inverse>)\<^sup>*" and "(y,z) \<in> r\<inverse>" and "(y,x) \<in> r\<^sup>*"
show "(z,x) \<in> r\<^sup>*"
proof (rule rtrancl_trans)
show "(z,y) \<in> r\<^sup>*" using `(y,z) \<in> r\<inverse>` by simp
next
show "(y,x) \<in> r\<^sup>*" using `(y,x) \<in> r\<^sup>*` by simp
qed
qed

lemma rtrancl_converseI: "(y,x) \<in> r\<^sup>* \<Longrightarrow> (x,y) \<in> (r\<inverse>)\<^sup>*"
proof (induct rule:rtrancl_induct)
show "(y,y) \<in> (r\<inverse>)\<^sup>*" by (rule rtrancl_refl)
next
fix u z
assume "(y,u) \<in> r\<^sup>*" and "(u,z) \<in> r" and "(u,y) \<in> (r\<inverse>)\<^sup>*"
show "(z,y) \<in> (r\<inverse>)\<^sup>*"
proof (rule rtrancl_trans)
show "(z,u) \<in> (r\<inverse>)\<^sup>*" using `(u,z) \<in> r` by auto
next
show "(u,y) \<in> (r\<inverse>)\<^sup>*" using `(u,y) \<in> (r\<inverse>)\<^sup>*` by simp
qed
qed

theorem rtrancl_converse: "(r\<inverse>)\<^sup>* = (r\<^sup>*)\<inverse>"
proof
show "(r\<inverse>)\<^sup>* \<subseteq> (r\<^sup>*)\<inverse>" by (auto simp add:rtrancl_converseD)
next
show "(r\<^sup>*)\<inverse> \<subseteq> (r\<inverse>)\<^sup>*" by (auto simp add:rtrancl_converseI)
qed

text {*
Puede demostrarse de manera más corta como sigue:
*}

theorem "(r\<inverse>)\<^sup>* = (r\<^sup>*)\<inverse>"
by (auto intro: rtrancl_converseI dest: rtrancl_converseD)

section {* Relaciones bien fundamentadas e inducción *}

text {*
La teoría de las relaciones bien fundamentadas es
HOL/Wellfounded_Relations.thy.

La relación-objeto "less_than" es el orden de los naturales que es
bien fundamentada:
· less_than_iff: ((x,y) \<in> less_than) = (x < y)
· wf_less_than: wf less_than

Notas sobre medidas:
· Imagen inversa de una relación mediante una función:
· inv_image_def: inv_image r f \<equiv> {(x,y). (f x,f y) \<in> r
· Conservación de la buena fundamentación:\\
· wf_inv_image: wf r \<Longrightarrow> wf (inv_image r f)
· Definición de la \textbf{medida}:\\
· measure_def: measure \<equiv> inv_image less_than
· Buena fundamentación de la medida:\\
· wf_measure: wf (measure f)
*}

text {*
Notas sobre el producto lexicográfico:
· Definición del producto lexicográfico (lex_prod_def)":
ra <*lex*> rb \<equiv> {((a,b),(a',b')). (a,a') \<in> ra \<or>
(a = a' \<and> (b,b') \<in> rb)}
· Conservación de la buena fundamentación:
· wf_lex_prod: \<lbrakk>wf ra; wf rb\<rbrakk> \<Longrightarrow> wf (ra <*lex*> rb)

El orden de multiconjuntos está en la teoría HOL/Library/Multiset.thy.

Inducción sobre relaciones bien fundamentadas:
· wf_induct: \<lbrakk>wf r; \<And>x. (\<And>y. (y,x) \<in> r \<Longrightarrow> P y) \<Longrightarrow> P x\<rbrakk> \<Longrightarrow> P a
*}

end
</source>

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

2012-01-31T19:05:14Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 11: Caso de estudio: Compilación de expresiones *} theory Tema_11 imports Main begin text {* El objetivo de este tema es contruir un com...'

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

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

types 'v binop = "'v \<Rightarrow> 'v \<Rightarrow> '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.
*}

primrec valor :: "'v expr \<Rightarrow> (nat \<Rightarrow> 'v) \<Rightarrow> '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 \<and>
valor (Var 2) id = 2 \<and>
valor (Var 2) (\<lambda>x. x+1) = 3 \<and>
valor (App (op +) (Const 3) (Var 2)) (\<lambda>x. x+1) = 6 \<and>
valor (App (op +) (Const 3) (Var 2)) (\<lambda>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.
*}

primrec ejec :: "'v instr list \<Rightarrow> (nat\<Rightarrow>'v) \<Rightarrow> 'v list \<Rightarrow> 'v list" where
"ejec [] ent vs = vs"
| "ejec (i#is) ent vs =
(case i of
IConst v \<Rightarrow> ejec is ent (v#vs)
| ILoad x \<Rightarrow> ejec is ent ((ent x)#vs)
| IApp f \<Rightarrow> 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] \<and>
ejec [ILoad 2, IConst 3] id [7] = [3,2,7] \<and>
ejec [ILoad 2, IConst 3] (\<lambda>x. x+4) [7] = [3,6,7] \<and>
ejec [ILoad 2, IConst 3, IApp (op +)] (\<lambda>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.
*}

primrec comp :: "'v expr \<Rightarrow> '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] \<and>
comp (Var 2) = [ILoad 2] \<and>
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 por inducción, lo generalizamos a
*}

theorem "\<forall>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:
"\<forall> 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:
"\<forall> 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 " \<forall>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 "\<dots> = ejec (xs@ys) ent (v#vs)" by simp
also have "\<dots> = ejec ys ent (ejec xs ent (v#vs))" using HI by simp
also have "\<dots> = ejec ys ent (ejec ((IConst v)#xs) ent vs)" by simp
also have "\<dots> = 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 " \<forall>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 "\<dots> = ejec (xs@ys) ent ((ent n)#vs)" by simp
also have "\<dots> = ejec ys ent (ejec xs ent ((ent n)#vs))" using HI by simp
also have "\<dots> = ejec ys ent (ejec ((ILoad n)#xs) ent vs)" by simp
also have "\<dots> = 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 "\<forall>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 "\<dots> = ejec (xs@ys) ent ((f (hd vs) (hd (tl vs)))#(tl(tl vs)))"
by simp
also have "\<dots> = ejec ys
ent
(ejec xs ent ((f (hd vs) (hd (tl vs)))#(tl(tl vs))))"
using HI by simp
also have "\<dots> = ejec ys ent (ejec ((IApp f)#xs) ent vs)" by simp
also have "\<dots> = 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 del teorema es la siguiente
*}

theorem "\<forall> vs. ejec (comp e) ent vs = (valor e ent)#vs"
proof (induct e)
fix v
show "\<forall>vs. ejec (comp (Const v)) ent vs = (valor (Const v) ent)#vs" by simp
next
fix x
show "\<forall>vs. ejec (comp (Var x)) ent vs = (valor (Var x) ent) # vs" by simp
next
fix f e1 e2
assume HI1: "\<forall>vs. ejec (comp e1) ent vs = (valor e1 ent) # vs"
and HI2: "\<forall>vs. ejec (comp e2) ent vs = (valor e2 ent) # vs"
show "\<forall>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 "\<dots> = ejec ((comp e1) @ [IApp f]) ent (ejec (comp e2) ent vs)"
using ejec_append by blast
also have "\<dots> = ejec [IApp f]
ent
(ejec (comp e1) ent (ejec (comp e2) ent vs))"
using ejec_append by blast
also have "\<dots> = ejec [IApp f] ent (ejec (comp e1) ent ((valor e2 ent)#vs))"
using HI2 by simp
also have "\<dots> = ejec [IApp f] ent ((valor e1 ent)#((valor e2 ent)#vs))"
using HI1 by simp
also have "\<dots> = (f (valor e1 ent) (valor e2 ent))#vs" by simp
also have "\<dots> = (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>

DAO2011 (Demostración asistida por ordenador)

2012-01-31T19:03:57Z

Jalonso: /* Razonamiento automático (2011-12) */

== Demostración asistida por ordenador ==
Este curso es una introducción a la demostración asistida por ordenador usando el sistema [http://www.cl.cam.ac.uk/research/hvg/Isabelle Isabelle/HOL/Isar]). Los objetivos del curso son:
* desarrollar la capacidad de razonamiento lógico,
* conocer formalismos de representación del conocimiento matemático,
* saber usar sistemas de razonamiento y
* desarrollar teorías matemáticas en sistemas de demostración automática.

Administrativamente, es un [http://www.cfp.us.es/web/ficha_avanzada.asp?id_titulo=846&tipo=FE&basica=1&curso=2010 curso de formación especializada] del [http://www.cfp.us.es/ Centro de Formación Permanente de la Universidad de Sevilla].

== Material para el curso ==
* [[Temas]]: Teorías de los temas.
* [[Ejercicios]]: Relaciones de ejercicios.
* [http://www.cs.us.es/~jalonso/cursos/dao/doc.html Documentación]: Enlaces con documentación.
* [http://www.cs.us.es/~jalonso/cursos/dao/sistemas.html Sistemas]: Sistemas utilizados.
* [http://www.glc.us.es/~jalonso/vestigium/tag/dao2011/ Diario]: Descripción diaria de las clases.

== Razonamiento automático (2011-12) ==
* [[Tema 6: Isabelle como un lenguaje funcional]].
* [[Tema 7: El lenguaje de demostración Isar]].
* [[Tema 8: Distinción de casos e inducción]].
* [[Tema 9: Patrones de demostración]].
* [[Tema 10: Heurísticas para la inducción y recursión general]].
* [[Tema 11: Caso de estudio: Compilación de expresiones]].
* [[Tema 12: Conjuntos, funciones y relaciones]].

Tema 10: Heurísticas para la inducción y recursión general

2012-01-31T15:28:16Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 10: Heurísticas para la inducción y recursión general *} theory Tema_10 imports Main Tema_7 Efficient_Nat begin section {* Heurísticas ...'

<source lang="isar">
header {* Tema 10: Heurísticas para la inducción y recursión general *}

theory Tema_10
imports Main Tema_7 Efficient_Nat
begin

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

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

value "inversa [2::nat,5,3]"

text {*
Definición. [Definición de inversa con acumuladores]
(inversaAc xs) es la inversa de la lista xs calculada con
acumuladores. Por ejemplo,
inversaAc [2,5,3] = [3,5,2]
inversaAcAux [2,5,3] [] = [3,5,2]
*}

primrec 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 [2::nat,5,3] []"
value "inversaAc [2::nat,5,3]"

text {*
Lema. [Ejemplo de equivalencia entre las definiciones]
La inversa de [1,2,3] es lo mismo calculada con la primera definición que
con la segunda.
*}

lemma "inversaAc [1,2,3] = inversa [1,2,3]"
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
*}

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 {*
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, activando "Trace
Simplifier" y D"|Trace Rules", que los lemas usados son
· append_assoc: (xs @ ys) @ zs = xs @ (ys @ zs)
· append.append_Cons: (x#xs)@ys = x#(xs@ys)
· append.append_Nil: []@ys = ys
Los dos últimos 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.append_Nil)
also have "… = (inversa xs)@([a]@ys)" by (simp only:append.append_Cons)
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)"

text {*
Nota. [Ejemplo de cálculo]
El cálculo del valor de la función de Ackermann para 2 y 3 se realiza
mediante "value"
*}

value "ack 2 3" (* devuelve 9 *)

text {*
Nota. [Definiciones recursivas generales]
· Las definiciones recursivas generales se identifican mediante "fun".
· 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

Lema. Para todos m y n, A(m,n) > n.
*}

lemma "ack m n > n"
proof (induct m n rule: ack.induct)
fix n :: "nat"
show "ack 0 n > n" by simp
next
fix m assume "ack m 1 > 1"
thus "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)"
thus "Suc n < ack (Suc m) (Suc n)" by simp
qed

text {*
El lema anterior se puede demostrar automáticamente, como sigue.
*}

lemma "ack m n > n"
by (induct m n rule: ack.induct) simp_all

text {*
Nota. [Inducción sobre recursión]
El formato para iniciar una demostración por inducción en la regla inductiva
correspondiente a la definición recursiva de la función f m n es
proof (induct m n rule:f.induct)
*}

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 {*
Nota. [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

Nota. [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 arbol ⇒ ('a ⇒ 'b) ⇒ 'b arbol" and
map_bosque :: "'a bosque ⇒ ('a ⇒ 'b) ⇒ 'b bosque" where
"map_arbol Hoja h = Hoja"
| "map_arbol (Nodo x b) h = Nodo (h x) (map_bosque b h)"
| "map_bosque Vacio h = Vacio"
| "map_bosque (ConsB a b) h = ConsB (map_arbol a h) (map_bosque b h)"

text {*
Lema. [Ejemplo de inducción cruzada]
· aplana_arbol (map_arbol a h) = map h (aplana_arbol a)
· aplana_bosque (map_bosque b h) = map h (aplana_bosque b)
*}

lemma "aplana_arbol (map_arbol a h) = map h (aplana_arbol a)
∧ aplana_bosque (map_bosque b h) = map h (aplana_bosque b)"
proof (induct_tac a and b)
show "aplana_arbol (map_arbol Hoja h) = map h (aplana_arbol Hoja)" by simp
next
fix x b
assume HI: "aplana_bosque (map_bosque b h) = map h (aplana_bosque b)"
have "aplana_arbol (map_arbol (Nodo x b) h)
= aplana_arbol (Nodo (h x) (map_bosque b h))" by simp
also have "… = (h x)#(aplana_bosque (map_bosque b h))" by simp
also have "… = (h x)#(map h (aplana_bosque b))" using HI by simp
also have "… = map h (aplana_arbol (Nodo x b))" by simp
finally show "aplana_arbol (map_arbol (Nodo x b) h)
= map h (aplana_arbol (Nodo x b))" .
next
show "aplana_bosque (map_bosque Vacio h) = map h (aplana_bosque Vacio)" by simp
next
fix a b
assume HI1: "aplana_arbol (map_arbol a h) = map h (aplana_arbol a)"
and HI2: "aplana_bosque (map_bosque b h) = map h (aplana_bosque b)"
have "aplana_bosque (map_bosque (ConsB a b) h)
= aplana_bosque (ConsB (map_arbol a h) (map_bosque b h))" by simp
also have "… = aplana_arbol(map_arbol a h)@aplana_bosque(map_bosque b h)"
by simp
also have "… = (map h (aplana_arbol a))@(map h (aplana_bosque b))"
using HI1 HI2 by simp
also have "… = map h (aplana_bosque (ConsB a b))" by simp
finally show "aplana_bosque (map_bosque (ConsB a b) h)
= map h (aplana_bosque (ConsB a b))" by simp
qed

lemma "aplana_arbol (map_arbol a h) = map h (aplana_arbol a)
∧ aplana_bosque (map_bosque b h) = map h (aplana_bosque b)"
by (induct_tac a and b) auto

end
</source>

DAO2011 (Demostración asistida por ordenador)

2012-01-31T15:27:17Z

Jalonso: /* Razonamiento automático (2011-12) */

Tema 9: Patrones de demostración

2012-01-31T13:07:23Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 9: Patrones de demostración *} theory Tema_9 imports Main begin section {* Demostraciones por casos *} text {* Nota. [Regla de elimina...'

<source lang="isar">
header {* Tema 9: Patrones de demostración *}

theory Tema_9
imports Main
begin

section {* Demostraciones por casos *}

text {*
Nota. [Regla de eliminación de la disyunción]
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R

Lema. [Ejemplo de demostración por casos]
P ∨ Q ⟹ Q ∨ P
*}

lemma disj_conmutativa: "P ∨ Q ⟹ Q ∨ P"
proof -
assume "P ∨ Q"
thus "Q ∨ P"
proof (rule disjE)
assume P
thus ?thesis by (rule disjI2)
next
assume Q
thus ?thesis by (rule disjI1)
qed
qed

text {*
Nota. El lema anterior puede demostrarse automáticamente como se
muestra a continuación.
*}

lemma disj_conmutativa_auto: "P ∨ Q ⟹ Q ∨ P"
by auto

section {* Negación *}

text {*
Reglas de la negación:
· notI: (P ⟹ False) ⟹ ¬P
· notE: ⟦¬P; P⟧ ⟹ R

Lema. [Ejemplo de demostración con negaciones]
Si x\<^bsup>2\<^esup>+y=13 e y ≠ 4, entonces x ≠ 3.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
proof (rule notI)
assume "x = 3"
with 1 have "y = 4" by simp
with 2 show "False" by (rule notE)
qed

text {*
La demostración puede hacerse automáticamente como se muestra a
continuación.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
proof (rule notI)
assume "x = 3"
with 1 2 show "False" by auto
qed

text {*
El lema anterior puede demostrarse más automáticamente como se muestra a
continuación.
*}

lemma
fixes x :: "nat"
assumes 1: "x * x + y = 13"
and 2: "y ≠ 4"
shows "x ≠ 3"
using assms
by auto

section {* Contradicciones *}

text {*
Regla de contradicción:
· FalseE: False ⟹ P

Lema. [Ejemplo de uso de la regla de contradicción]
Si 1=2, entonces 3=7.
*}

lemma
assumes "1 = (2::nat)"
shows "3 = (7::nat)"
proof -
have "False" using assms by simp
thus "3 = (7::nat)" by (rule FalseE)
qed

text {*
El lema puede demostrarse automáticamente, como sigue.
*}

lemma
assumes "1 = (2::nat)"
shows "3 = (7::nat)"
using assms
by auto

text {*
Lema. [Ejemplo de demostración por casos y contradicción]
¬P, P ∨ Q ⊢ Q
*}

lemma disjCE:
assumes "¬P" and "P ∨ Q"
shows "Q"
using `P ∨ Q`
proof (rule disjE)
assume "P"
thus "Q" using `¬P` by contradiction
next
assume "Q"
thus "Q" by assumption
qed

section {* Equivalencias *}

text {*
Reglas de equivalencia:
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P

Lema. [Ejemplo de introducción de equivalencia]
La fórmula
(R ⟶ C) ∧ (S ⟶ C))
es equivalente a
R ∨ S ⟶ C
*}

lemma "((R ⟶ C) ∧ (S ⟶ C)) = (R ∨ S ⟶ C)"
proof (rule iffI)
assume "(R ⟶ C) ∧ (S ⟶ C)"
thus "R ∨ S ⟶ C" by blast
next
assume "R ∨ S ⟶ C"
thus "(R ⟶ C) ∧ (S ⟶ C)" by blast
qed

text {*
El método "blast":
En la demostración anterior es la primera vez que se usa el método de
razonamiento automático "blast".

Nota. El lema anterior puede demostrarse automáticamente como se
muestra a continuación.
*}

lemma "((R ⟶ C) ∧ (S ⟶ C)) = (R ∨ S ⟶ C)"
by auto

text {*
Lema. [Ejemplo de eliminación de equivalencia]
· A ⟷ B, A ⊢ B
· A ⟷ B, B ⊢ A
*}

lemma assumes "A = B" and "A" shows "B"
using assms
by (rule iffD1)

lemma assumes "A = B" and "B" shows "A"
using assms
by (rule iffD2)

end
</source>

DAO2011 (Demostración asistida por ordenador)

2012-01-31T13:06:29Z

Jalonso: /* Razonamiento automático (2011-12) */

Tema 8: Distinción de casos e inducción

2012-01-31T12:48:28Z

Jalonso:

<source lang="isar">
header {* Tema 8: Distinción de casos e inducción *}

theory Tema_8
imports Main Parity
begin

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Lema. [Demostración por distinción de casos booleanos]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof cases
assume "A" thus ?thesis ..
next
assume "¬A" thus ?thesis ..
qed

text {*
Lema. [Demostración por distinción de casos booleanos nominados]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof (cases "A")
case True thus ?thesis ..
next
case False thus ?thesis ..
qed

text {*
El método "cases" sobre una fórmula:
· 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 {*
Lema. [Distinción de casos sobre listas]
La longitud del resto de una lista es la longitud de la lista menos 1.
*}

lemma "length(tl xs) = length xs - 1"
proof (cases xs)
case Nil thus ?thesis by simp
next
case Cons thus ?thesis by simp
qed

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.

Lema. [Ejemplo de análisis de casos]
El resultado de eliminar los n+1 primeros elementos de xs es el mismo
que eliminar los n primeros elementos del resto de xs.
*}

lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil thus "drop (n + 1) xs = drop n (tl xs)" by simp
next
case Cons thus "drop (n + 1) xs = drop n (tl xs)" by simp
qed

text {*
La función drop 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
primrec drop:: "nat => 'a list => 'a list" where
drop_Nil: "drop n [] = []" |
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

section {* Inducción matemática *}
thm nat.induct
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

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

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

text {*
Lema. [Ejemplo de suma de impares]
La suma de los 3 primeros números impares es 9.
*}

lemma "suma_impares 2 = 4"
by (simp add: suma_impares_def)

text {*
La suma de los 3 primero número impares se puede calcular mediante "value".
*}

value "suma_impares 3"

text {*
Lema. [Ejemplo de demostración por inducción matemática]
La suma de los n primeros números impares es n^2.

Demostración automática: Por inducción en n.
*}

lemma "suma_impares n = n * n"
by (induct n) simp_all

text {*
En la demostración "by (induct n) simp_all" se aplica inducción en n y
los dos casos se prueban por simplificación.

Demostración del lema anterior usando patrones.
*}

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

text {*
Patrones: Cualquier fórmula seguida de (is patrón) equipara el patrón
con la fórmula.

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

text {*
Definición. [Números pares]
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 {*
Lema. [Ejemplo de inducción y existenciales]
Para todo número natural n, se verifica que n*(n+1) par.
*}

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))"
hence "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" by (rule exE)
hence "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
hence "∃m. (Suc n)*((Suc n)+1) = m+m" by (rule exI)
thus "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

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

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

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)
thus "par n = even n" by presburger
qed

text {*
En la demostración anterior hemos usado la táctica "presburger" que
corresponde a la aritmética de Presburger.
*}

section {* Inducción estructural *}

thm list.induct

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.

Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
primrec
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"

Lema. [Ejemplo de inducción sobre listas]
La concatenación de listas es asociativa.

Demostración automática del lema.
*}

lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

text {*
Demostración estructurada del lema anterior.
*}

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

text {*
Ejercicio. [Árboles binarios]
Definir un tipo de dato para los árboles binarios.
*}

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

text {*
Ejercicio. [Imagen especular]
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

primrec espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (Hoja a) = (Hoja a)"
| "espejo (Nodo f x y) = (Nodo f (espejo y) (espejo x))"

text {*
Ejercicio. [La imagen especular es involutiva]
Demostrar que la función "espejo" involutiva; es decir, para cualquier
árbol t, se tiene que
espejo (espejo(t)) = t.

Demostración automática del lema.
*}

lemma espejo_involutiva_1: "espejo(espejo(t)) = t"
by (induct t) auto

text {*
Demostración estructurada del lema.
*}

lemma espejo_involutiva: "espejo(espejo(t)) = t" (is "?P t")
proof (induct t)
fix x :: 'a show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "espejo(espejo(Nodo x t1 t2)) = espejo(Nodo x (espejo t2) (espejo t1))"
by simp
also have "… = Nodo x (espejo (espejo t1)) (espejo (espejo t2))" by simp
also have "… = Nodo x t1 t2" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Ejercicio. [Aplanamiento de árboles]
Definir la función "aplana" que aplane los árboles recorriéndolos en
orden infijo.
*}

primrec aplana :: "'a arbol ⇒ 'a list" where
"aplana (Hoja a) = [a]"
| "aplana (Nodo x t1 t2) = (aplana t1)@[x]@(aplana t2)"

text {*
Ejercicio. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo t) = rev (aplana t)

Demostración automática del lema.
*}

lemma "aplana (espejo t) = rev (aplana t)"
by (induct t) auto

text {*
Demostración estructurada del lema anterior.
*}

lemma "aplana (espejo t) = rev (aplana t)" (is "?P t")
proof (induct t)
fix x :: 'a
show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "aplana (espejo (Nodo x t1 t2)) =
aplana (Nodo x (espejo t2) (espejo t1))" by simp
also have "… = (aplana(espejo t2))@[x]@(aplana(espejo t1))" by simp
also have "… = (rev(aplana t2))@[x]@(rev(aplana t1))" using h1 h2 by simp
also have "… = rev((aplana t1)@[x]@(aplana t2))" by simp
also have "… = rev(aplana (Nodo x t1 t2))" by simp
finally show ?thesis .
qed
qed

end
</source>

Tema 8: Distinción de casos e inducción

2012-01-31T12:43:08Z

Jalonso:

<source lang="isar">
header {* Tema 8: Distinción de casos e inducción *}

theory Tema_8
imports Main Parity
begin

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Lema. [Demostración por distinción de casos booleanos]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof cases
assume "A" thus ?thesis ..
next
assume "¬A" thus ?thesis ..
qed

text {*
Lema. [Demostración por distinción de casos booleanos nominados]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof (cases "A")
case True thus ?thesis ..
next
case False thus ?thesis ..
qed

text {*
El método "cases" sobre una fórmula:
· 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 {*
Lema. [Distinción de casos sobre listas]
La longitud del resto de una lista es la longitud de la lista menos 1.
*}

lemma "length(tl xs) = length xs - 1"
proof (cases xs)
case Nil thus ?thesis by simp
next
case Cons thus ?thesis by simp
qed

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.

Lema. [Ejemplo de análisis de casos]
El resultado de eliminar los n+1 primeros elementos de xs es el mismo
que eliminar los n primeros elementos del resto de xs.
*}

lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil thus "drop (n + 1) xs = drop n (tl xs)" by simp
next
case Cons thus "drop (n + 1) xs = drop n (tl xs)" by simp
qed

text {*
La función drop 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
primrec drop:: "nat => 'a list => 'a list" where
drop_Nil: "drop n [] = []" |
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

section {* Inducción matemática *}
thm nat.induct
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

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

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

text {*
Lema. [Ejemplo de suma de impares]
La suma de los 3 primeros números impares es 9.
*}

lemma "suma_impares 2 = 4"
by (simp add: suma_impares_def)

text {*
La suma de los 3 primero número impares se puede calcular mediante
"value".
*}

value "suma_impares 3"

text {*
Lema. [Ejemplo de demostración por inducción matemática]
La suma de los n primeros números impares es n^2.

Demostración automática: Por inducción en n.
*}

lemma "suma_impares n = n * n"
by (induct n) simp_all

text {*
En la demostración "by (induct n) simp_all" se aplica inducción en n y
los dos casos se prueban por simplificación.

Demostración del lema anterior usando patrones.
*}

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

text {*
Patrones: Cualquier fórmula seguida de (is patrón) equipara el patrón
con la fórmula.

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

text {*
Definición. [Números pares]
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 {*
Lema. [Ejemplo de inducción y existenciales]
Para todo número natural n, se verifica que n*(n+1) par.
*}

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))"
hence "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" by (rule exE)
hence "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
hence "∃m. (Suc n)*((Suc n)+1) = m+m" by (rule exI)
thus "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

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

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

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)
thus "par n = even n" by presburger
qed

text {*
En la demostración anterior hemos usado la táctica "presburger" que
corresponde a la aritmética de Presburger.
*}

section {* Inducción estructural *}

thm list.induct

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.

Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
primrec
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"

Lema. [Ejemplo de inducción sobre listas]
La concatenación de listas es asociativa.

Demostración automática del lema.
*}

lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

text {*
Demostración estructurada del lema anterior.
*}

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

text {*
Ejercicio. [Árboles binarios]
Definir un tipo de dato para los árboles binarios.
*}

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

text {*
Ejercicio. [Imagen especular]
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

primrec espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (Hoja a) = (Hoja a)"
| "espejo (Nodo f x y) = (Nodo f (espejo y) (espejo x))"

text {*
Ejercicio. [La imagen especular es involutiva] \label{espInv}
Demostrar que la función @{term "espejo"} es involutiva; es decir, para
cualquier árbol @{term "t"},
\newline \hspace*{1cm}
@{term "espejo(espejo(t))=t"}.
\end{ejercicio}

Demostración automática de \ref{espInv}.
*}

lemma espejo_involutiva_1: "espejo(espejo(t)) = t"
by (induct t) auto

text {*

Demostración estructurada de \ref{espInv}.
*}

lemma espejo_involutiva: "espejo(espejo(t)) = t" (is "?P t")
proof (induct t)
fix x :: 'a show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "espejo(espejo(Nodo x t1 t2)) = espejo(Nodo x (espejo t2) (espejo t1))"
by simp
also have "… = Nodo x (espejo (espejo t1)) (espejo (espejo t2))" by simp
also have "… = Nodo x t1 t2" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Ejercicio. [Aplanamiento de árboles]
Definir la función @{term "aplana"} que aplane los árboles recorriéndolos en
orden infijo.
\end{ejercicio}
*}

primrec aplana :: "'a arbol ⇒ 'a list" where
"aplana (Hoja a) = [a]"
| "aplana (Nodo x t1 t2) = (aplana t1)@[x]@(aplana t2)"

text {*
Ejercicio. [Aplanamiento de la imagen especular]
aplana (espejo t) = rev (aplana t)

Demostración automática del lema.
*}

lemma "aplana (espejo t) = rev (aplana t)"
by (induct t) auto

text {*
Demostración estructurada del lema anterior.
*}

lemma "aplana (espejo t) = rev (aplana t)" (is "?P t")
proof (induct t)
fix x :: 'a
show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "aplana (espejo (Nodo x t1 t2)) =
aplana (Nodo x (espejo t2) (espejo t1))" by simp
also have "… = (aplana(espejo t2))@[x]@(aplana(espejo t1))" by simp
also have "… = (rev(aplana t2))@[x]@(rev(aplana t1))" using h1 h2 by simp
also have "… = rev((aplana t1)@[x]@(aplana t2))" by simp
also have "… = rev(aplana (Nodo x t1 t2))" by simp
finally show ?thesis .
qed
qed

end
</source>

Tema 8: Distinción de casos e inducción

2012-01-31T11:12:55Z

Jalonso:

<source lang="isar">
header {* Tema 8: Distinción de casos e inducción *}

theory Tema_8
imports Main Parity
begin

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Lema. [Demostración por distinción de casos booleanos]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof cases
assume "A" thus ?thesis ..
next
assume "¬A" thus ?thesis ..
qed

text {*
Lema. [Demostración por distinción de casos booleanos nominados]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof (cases "A")
case True thus ?thesis ..
next
case False thus ?thesis ..
qed

text {*
El método "cases" sobre una fórmula:
· 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.
\end{nota}
*}

subsection {* Distinción de casos sobre otros tipos de datos *}

text {*
Lema. [Distinción de casos sobre listas]
La longitud del resto de una lista es la longitud de la lista menos 1.
*}

lemma "length(tl xs) = length xs - 1"
proof (cases xs)
case Nil thus ?thesis by simp
next
case Cons thus ?thesis by simp
qed

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.

Lema. [Ejemplo de análisis de casos]
El resultado de eliminar los n+1 primeros elementos de xs es el mismo
que eliminar los n primeros elementos del resto de xs.
*}

lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil thus "drop (n + 1) xs = drop n (tl xs)" by simp
next
case Cons thus "drop (n + 1) xs = drop n (tl xs)" by simp
qed

text {*
La función drop 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
primrec drop:: "nat => 'a list => 'a list" where
drop_Nil: "drop n [] = []" |
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

section {* Inducción matemática *}
thm nat.induct
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

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

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

text {*
Lema. [Ejemplo de suma de impares]
La suma de los 3 primeros números impares es 9.
*}

lemma "suma_impares 2 = 4"
by (simp add: suma_impares_def)

text {*
La suma de los 3 primero número impares se puede calcular mediante
"value".
*}

value "suma_impares 3"

text {*
Lema. [Ejemplo de demostración por inducción matemática]
La suma de los n primeros números impares es n^2.

Demostración automática: Por inducción en n.
*}

lemma "suma_impares n = n * n"
by (induct n) simp_all

text {*
En la demostración "by (induct n) simp_all" se aplica inducción en n y
los dos casos se prueban por simplificación.

Demostración del lema anterior usando patrones.
*}

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

text {*
Patrones: Cualquier fórmula seguida de (is patrón) equipara el patrón
con la fórmula.

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

text {*
Definición. [Números pares]
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 {*
Lema. [Ejemplo de inducción y existenciales]
Para todo número natural n, se verifica que n*(n+1) par.
*}

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))"
hence "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" by (rule exE)
hence "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
hence "∃m. (Suc n)*((Suc n)+1) = m+m" by (rule exI)
thus "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

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

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

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)
thus "par n = even n" by presburger
qed

text {*
En la demostración anterior hemos usado la táctica "presburger" que
corresponde a la aritmética de Presburger.
*}

section {* Inducción estructural *}

thm list.induct

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.

Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
primrec
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"

Lema. [Ejemplo de inducción sobre listas]
La concatenación de listas es asociativa.

Demostración automática del lema.
*}

lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

text {*
Demostración estructurada del lema anterior.
*}

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

text {*
Ejercicio. [Árboles binarios]
Definir un tipo de dato para los árboles binarios.
*}

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

text {*
Ejercicio. [Imagen especular]
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

primrec espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (Hoja a) = (Hoja a)"
| "espejo (Nodo f x y) = (Nodo f (espejo y) (espejo x))"

text {*
Ejercicio. [La imagen especular es involutiva] \label{espInv}
Demostrar que la función @{term "espejo"} es involutiva; es decir, para
cualquier árbol @{term "t"},
\newline \hspace*{1cm}
@{term "espejo(espejo(t))=t"}.
\end{ejercicio}

Demostración automática de \ref{espInv}.
*}

lemma espejo_involutiva_1: "espejo(espejo(t)) = t"
by (induct t) auto

text {*

Demostración estructurada de \ref{espInv}.
*}

lemma espejo_involutiva: "espejo(espejo(t)) = t" (is "?P t")
proof (induct t)
fix x :: 'a show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "espejo(espejo(Nodo x t1 t2)) = espejo(Nodo x (espejo t2) (espejo t1))"
by simp
also have "… = Nodo x (espejo (espejo t1)) (espejo (espejo t2))" by simp
also have "… = Nodo x t1 t2" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Ejercicio. [Aplanamiento de árboles]
Definir la función @{term "aplana"} que aplane los árboles recorriéndolos en
orden infijo.
\end{ejercicio}
*}

primrec aplana :: "'a arbol ⇒ 'a list" where
"aplana (Hoja a) = [a]"
| "aplana (Nodo x t1 t2) = (aplana t1)@[x]@(aplana t2)"

text {*
Ejercicio. [Aplanamiento de la imagen especular]
aplana (espejo t) = rev (aplana t)

Demostración automática del lema.
*}

lemma "aplana (espejo t) = rev (aplana t)"
by (induct t) auto

text {*
Demostración estructurada del lema anterior.
*}

lemma "aplana (espejo t) = rev (aplana t)" (is "?P t")
proof (induct t)
fix x :: 'a
show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "aplana (espejo (Nodo x t1 t2)) =
aplana (Nodo x (espejo t2) (espejo t1))" by simp
also have "… = (aplana(espejo t2))@[x]@(aplana(espejo t1))" by simp
also have "… = (rev(aplana t2))@[x]@(rev(aplana t1))" using h1 h2 by simp
also have "… = rev((aplana t1)@[x]@(aplana t2))" by simp
also have "… = rev(aplana (Nodo x t1 t2))" by simp
finally show ?thesis .
qed
qed

end
</source>

Tema 8: Distinción de casos e inducción

2012-01-31T11:11:20Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 8: Distinción de casos e inducción *} theory Tema_8 imports Main Parity begin section {* Razonamiento por distinción de casos *} subsec...'

<source lang="isar">
header {* Tema 8: Distinción de casos e inducción *}

theory Tema_8
imports Main Parity
begin

section {* Razonamiento por distinción de casos *}

subsection {* Distinción de casos booleanos *}

text {*
Lema. [Demostración por distinción de casos booleanos]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof cases
assume "A" thus ?thesis ..
next
assume "¬A" thus ?thesis ..
qed

text {*
Lema. [Demostración por distinción de casos booleanos nominados]
¬A ∨ A
*}

lemma "¬A ∨ A"
proof (cases "A")
case True thus ?thesis ..
next
case False thus ?thesis ..
qed

text {*
El método "cases" sobre una fórmula:
· 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.
\end{nota}
*}

subsection {* Distinción de casos sobre otros tipos de datos *}

text {*
Lema. [Distinción de casos sobre listas]
La longitud del resto de una lista es la longitud de la lista menos 1.
*}

lemma "length(tl xs) = length xs - 1"
proof (cases xs)
case Nil thus ?thesis by simp
next
case Cons thus ?thesis by simp
qed

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.

Lema. [Ejemplo de análisis de casos]
El resultado de eliminar los n+1 primeros elementos de xs es el mismo
que eliminar los n primeros elementos del resto de xs.
*}

lemma "drop (n + 1) xs = drop n (tl xs)"
proof (cases xs)
case Nil thus "drop (n + 1) xs = drop n (tl xs)" by simp
next
case Cons thus "drop (n + 1) xs = drop n (tl xs)" by simp
qed

text {*
La función drop 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
primrec drop:: "nat => 'a list => 'a list" where
drop_Nil: "drop n [] = []" |
drop_Cons: "drop n (x#xs) = (case n of
0 => x#xs |
Suc(m) => drop m xs)"
*}

section {* Inducción matemática *}
thm nat.induct
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

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

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

text {*
Lema. [Ejemplo de suma de impares]
La suma de los 3 primeros números impares es 9.
*}

lemma "suma_impares 2 = 4"
by (simp add: suma_impares_def)

text {*
La suma de los 3 primero número impares se puede calcular mediante
"value".
*}

value "suma_impares 3"

text {*
Lema. [Ejemplo de demostración por inducción matemática]
La suma de los n primeros números impares es n^2.

Demostración automática: Por inducción en n.
*}

lemma "suma_impares n = n * n"
by (induct n) simp_all

text {*
En la demostración "by (induct n) simp_all" se aplica inducción en n y
los dos casos se prueban por simplificación.

Demostración del lema anterior usando patrones.
*}

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

text {*
Patrones: Cualquier fórmula seguida de (is patrón) equipara el patrón
con la fórmula.

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

text {*
Definición. [Números pares]
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 {*
Lema. [Ejemplo de inducción y existenciales]
Para todo número natural n, se verifica que n*(n+1) par.
*}

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))"
hence "∃m. n*(n+1) = m+m" by (simp add:par_def)
then obtain m where m: "n*(n+1) = m+m" by (rule exE)
hence "(Suc n)*((Suc n)+1) = (m+n+1)+(m+n+1)" by auto
hence "∃m. (Suc n)*((Suc n)+1) = m+m" by (rule exI)
thus "par ((Suc n)*((Suc n)+1))" by (simp add:par_def)
qed

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

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

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)
thus "par n = even n" by presburger
qed

text {*
En la demostración anterior hemos usado la táctica "presburger" que
corresponde a la aritmética de Presburger.
*}

section {* Inducción estructural *}

thm list.induct

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.

Concatenación de listas:
En la teoría List.thy está definida la concatenación de listas (que
se representa por @) como sigue
primrec
append_Nil: "[]@ys = ys"
append_Cons: "(x#xs)@ys = x#(xs@ys)"

Lema. [Ejemplo de inducción sobre listas]
La concatenación de listas es asociativa.

Demostración automática del lema.
*}

lemma conc_asociativa_1: "xs @ (ys @ zs) = (xs @ ys) @ zs"
by (induct xs) simp_all

text {*
Demostración estructurada del lema anterior.
*}

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

text {*
Ejercicio. [Árboles binarios]
Definir un tipo de dato para los árboles binarios.
*}

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

text {*
Ejercicio. [Imagen especular]
Definir la función "espejo" que aplicada a un árbol devuelve su imagen
especular.
*}

primrec espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (Hoja a) = (Hoja a)"
| "espejo (Nodo f x y) = (Nodo f (espejo y) (espejo x))"

text {*
Ejercicio. [La imagen especular es involutiva] \label{espInv}
Demostrar que la función @{term "espejo"} es involutiva; es decir, para
cualquier árbol @{term "t"},
\newline \hspace*{1cm}
@{term "espejo(espejo(t))=t"}.
\end{ejercicio}

Demostración automática de \ref{espInv}.
*}

lemma espejo_involutiva_1: "espejo(espejo(t)) = t"
by (induct t) auto

text {*

Demostración estructurada de \ref{espInv}.
*}

lemma espejo_involutiva: "espejo(espejo(t)) = t" (is "?P t")
proof (induct t)
fix x :: 'a show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "espejo(espejo(Nodo x t1 t2)) = espejo(Nodo x (espejo t2) (espejo t1))"
by simp
also have "… = Nodo x (espejo (espejo t1)) (espejo (espejo t2))" by simp
also have "… = Nodo x t1 t2" using h1 h2 by simp
finally show ?thesis .
qed
qed

text {*
Ejercicio. [Aplanamiento de árboles]
Definir la función @{term "aplana"} que aplane los árboles recorriéndolos en
orden infijo.
\end{ejercicio}
*}

primrec aplana :: "'a arbol ⇒ 'a list" where
"aplana (Hoja a) = [a]"
| "aplana (Nodo x t1 t2) = (aplana t1)@[x]@(aplana t2)"

text {*
Ejercicio. [Aplanamiento de la imagen especular]
aplana (espejo t) = rev (aplana t)

Demostración automática del lema.
*}

lemma "aplana (espejo t) = rev (aplana t)"
by (induct t) auto

text {*
Demostración estructurada del lema anterior.
*}

lemma "aplana (espejo t) = rev (aplana t)" (is "?P t")
proof (induct t)
fix x :: 'a
show "?P (Hoja x)" by simp
next
fix t1 :: "'a arbol" assume h1: "?P t1"
fix t2 :: "'a arbol" assume h2: "?P t2"
fix x :: 'a
show "?P (Nodo x t1 t2)"
proof -
have "aplana (espejo (Nodo x t1 t2)) =
aplana (Nodo x (espejo t2) (espejo t1))" by simp
also have "… = (aplana(espejo t2))@[x]@(aplana(espejo t1))" by simp
also have "… = (rev(aplana t2))@[x]@(rev(aplana t1))" using h1 h2 by simp
also have "… = rev((aplana t1)@[x]@(aplana t2))" by simp
also have "… = rev(aplana (Nodo x t1 t2))" by simp
finally show ?thesis .
qed
qed

end
</source>

DAO2011 (Demostración asistida por ordenador)

2012-01-31T11:10:11Z

Jalonso: /* Razonamiento automático (2011-12) */

Tema 7: El lenguaje de demostración Isar

2012-01-31T09:45:30Z

Jalonso: Página creada con '<source lang="isar"> header {* El lenguaje de demostración Isar *} theory Tema_7 imports Main begin text {* Este tema describe los elementos básicos del lenguaje de demost...'

<source lang="isar">
header {* El lenguaje de demostración Isar *}

theory Tema_7
imports Main
begin

text {*
Este tema describe los elementos básicos del lenguaje de demostración
Isar (Intelligible semi-automated reasoning).
*}

section {* Panorama de la sintaxis (simplificada) de Isar *}

text {*
Representación de lemas (y teoremas)
· Un lema (o teorema) comienza con una etiqueta seguida por algunas
premisas y una conclusión.
· Las premisas se introducen con la palabra "assumes" y se separan
con "and".
· Cada premisa puede etiquetarse para referenciarse en la demostración.
· La conclusión se introduce con la palabra "shows".

Gramática (simplificada) de las demostraciones en Isar
<demostración> ::= proof <método> <declaración>* qed
| by <método>
<declaración> ::= fix <variable>+
| assume <proposición>+
| (from <hecho>+)? have <proposición>+ <demostración>
| (from <hecho>+)? show <proposición>+ <demostración>
<proposición> ::= (<etiqueta>:)? <cadena>
hecho ::= <etiqueta>
método ::= -
| this
| rule <hecho>
| simp
| blast
| auto
| induct <variable>

La declaración "show" demuestra la conclusión de la demostración
mientras que la declaración "have" demuestra un resultado intermedio.
*}

section {* Razonamiento proposicional *}

text {*
Regla de introducción de la conjunción:
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q

Nota: Se puede consultar mediante
thm conjI

Lema. [Ejemplo de introducción de conjunción con razonamiento progresivo]
P, Q ⊢ P ∧ (Q ∧ P)

Demostración. Estamos suponiendo
P (1)
y
Q (2)
De (2) y (1), por introducción de la conjunción, se tiene
Q ∧ P (3)
De (1) y (3), por introducción de la conjunción, se tiene
P ∧ (Q ∧ P)
*}

lemma conj2:
assumes 1: P and 2: "Q"
shows "P ∧ (Q ∧ P)"
proof -
from 2 1 have 3: "Q ∧ P" by (rule conjI)
from 1 3 show "P ∧ (Q ∧ P)" by (rule conjI)
qed

text {*
Razonamiento progresivo y regresivo en Isabelle:
· Isabelle soporta razonamiento progresivo. La anterior demostración
es una muestra.
· Isabelle soporta razonamiento regresivo. La siguiente demostración
es una muestra.

Lema. [Ejemplo de introducción de la conjunción con razonamiento regresivo]
P, Q ⊢ P ∧ (Q ∧ P)

Demostración. Estamos suponiendo
P (1)
y
Q (2)

Para demostrar el lema, por introducción de la conjunción, basta probar
P
y
Q ∧ P (3)

La condición 'P' se tiene por la hipótesis (1). Para demostrar
la condición (3), por introducción de la conjunción, basta probar
Q
y
P
La condición 'Q' se tiene por la hipótesis (2) y la condición 'P' se
tiene por la hipótesis (1).
*}

lemma
assumes 1: "P" and 2: "Q"
shows "P ∧ (Q ∧ P)"
proof (rule conjI)
from 1 show "P" by this
next
show "Q ∧ P"
proof (rule conjI)
from 2 show "Q" by this
next
from 1 show "P" by this
qed
qed

text {*
El método "this" demuestra el objetivo usando el hecho actual; es
decir, el de la cláusula "from".

Reglas de eliminación de la conjunción:
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ P

Regla de introducción de la implicación:
· impI: (P ⟹ Q) ⟹ P ⟶ Q

Lema. [Ejemplo de razonamiento híbrido]
Sean a y b dos números naturales. Si 0 < a y a < b, entonces a*a < b*b.
*}

lemma
fixes a b :: "nat"
shows "0 < a ∧ a < b ⟶ a * a < b * b"
proof (rule impI)
assume x: "0 < a ∧ a < b"
from x have za: "0 < a" by (rule conjunct1)
from x have ab: "a < b" by (rule conjunct2)
from za ab have aa: "a*a < a*b" by simp
from ab have bb: "a*b < b*b" by simp
from aa bb show "a*a < b*b" by arith
qed

text {*
Modus ponens:
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q

Reglas de introducción de la disyunción:
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q

Regla de eliminación de la disyunción:
. disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R

Lema. [Razonamiento por casos]
A ∨ B, A ⟶ C, B ⟶ C ⊢ C
*}

lemma
assumes ab: "A ∨ B" and ac: "A ⟶ C" and bc: "B ⟶ C"
shows "C"
proof -
note ab
moreover {
assume a: "A"
from ac a have "C" by (rule mp) }
moreover {
assume b: "B"
from bc b have "C" by (rule mp) }
ultimately show "C" by (rule disjE)
qed

text {*
Resumen de reglas proposicionales:
· TrueI: True
· FalseE: False ⟹ P
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
· conjE: ⟦P ∧ Q; ⟦P; Q⟧ ⟹ R⟧ ⟹ R
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
· notI: (P ⟹ False) ⟹ ¬P
· notE: ⟦¬P; P⟧ ⟹ R
· impI: (P ⟹ Q) ⟹ P ⟶ Q
· impE: ⟦P ⟶ Q; P; Q ⟹ R⟧ ⟹ R
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
· iff: (P ⟶ Q) ⟶ (Q ⟶ P) ⟶ P = Q
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
· iffE: ⟦P = Q; ⟦P ⟶ Q; Q ⟶ P⟧ ⟹ R⟧ ⟹ R
· ccontr: (¬P ⟹ False) ⟹ P
· classical: (¬P ⟹ P) ⟹ P && @{thm classical } \\
· exlude_middle: ¬P ∨ P
· disjCI: (¬Q ⟹ P) ⟹ P ∨ Q
· impCE: ⟦P ⟶ Q; ¬P ⟹ R; Q ⟹ R⟧ ⟹ R
· iffCE: ⟦P = Q; ⟦P; Q⟧ ⟹ R; ⟦¬P; ¬Q⟧ ⟹ R⟧ ⟹ R
· notnotD: ¬¬P ⟹ P
· swap: ⟦¬P; ¬R ⟹ P⟧ ⟹ R

Referencia de reglas de inferencia: Más información sobre las reglas
de inferencia se encuentra en la sección 2.2 de "Isabelle's Logics:
HOL".
*}

section {* Atajos de Isar *}

text {*
Isar tiene muchos atajos, como los siguientes:
this | éste | el hecho probado en la declaración anterior
then | entonces | from this
hence | por lo tanto | then have
thus | de esta manera | then show
with hecho+ | con | from hecho+ and this
. | por ésto | by this
.. | trivialmente | by regla (Isabelle adivina la regla)

Razonamiento acumulativo:
Una sucesión de hechos que se van a usar como premisa en una declaración
puede agruparse usando "moreover" (además) y usarse en la declaración
usando "ultimately" (finalmente).

Lema. [Ejemplo de uso de atajos y razonamiento acumulativo]
A ∧ B ⊢ B ∧ A.
*}

lemma "A ∧ B ⟶ B ∧ A"
proof (rule impI)
assume ab: "A ∧ B"
hence "B" by (rule conjunct2)
moreover from ab have "A" ..
ultimately show "B ∧ A" by (rule conjI)
qed

section {* Cuantificadores universal y existencial *}

thm allE
text {*
Reglas del cuantificador universal:
· allI: (⋀x. P x) ⟹ ∀x. P x
· allE: ⟦∀x. P x; P x ⟹ R⟧ ⟹ R
En la regla allI la nueva variable se introduce mediante la palabra "fix".

Lema. [Ejemplo con cuantificadores universales]
∀x. P ⟶ Q x ⊢ P ⟶ (∀x. Q x)
*}

lemma
assumes a: "∀ x. P ⟶ Q x"
shows "P ⟶ (∀ x. Q x)"
proof (rule impI)
assume p: "P"
show "∀ x. Q x"
proof (rule allI)
fix y
from a have pq: "P ⟶ Q y" by (rule allE)
from pq p show "Q y" by (rule mp)
qed
qed

text {*
Reglas del cuantificador existencial:
· exI: P x ⟹ ∃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)"

Lema. [Ejemplo con cuantificador existencial y demostración progresiva]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))
*}

lemma
assumes e: "∃ x. P ∧ Q(x)"
shows "P ∧ (∃ x. Q(x))"
proof -
from e obtain y where f: "P ∧ Q(y)" by (rule exE)
from f have p: "P" by (rule conjunct1)
from f have q: "Q(y)" by (rule conjunct2)
from q have eq: "∃ x. Q(x)" by (rule exI)
from p eq show "P ∧ (∃ x. Q(x))" by (rule conjI)
qed

text {*
Lema. [Ejemplo con cuantificador existencial y demostración automática]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))
*}

lemma
assumes e: "∃ x. P ∧ Q(x)"
shows "P ∧ (∃ x. Q(x))"
proof -
from e obtain y where f: "P ∧ Q(y)" ..
from f have p: "P" ..
from f have q: "Q(y)" ..
from q have eq: "∃x. Q(x)" ..
from p eq show "P ∧ (∃x. Q(x))" ..
qed

text {*
Lema. [Ejemplo con cuantificador existencial y demostración regresiva]
∃x. P ∧ Q(x) ⊢ P ∧ (∃x. Q(x))"
*}

lemma
assumes e: "∃x. P ∧ Q(x)"
shows "P ∧ (∃x. Q(x))"
proof (rule conjI)
show "P"
proof -
from e obtain y where p: "P ∧ Q(y)" by (rule exE)
from p show "P" by (rule conjunct1)
qed
show "∃x. Q(x)"
proof -
from e obtain y where p: "P ∧ Q(y)" by (rule exE)
from p have q: "Q(y)" by (rule conjunct2)
from q show "∃x. Q(x)" by (rule exI)
qed
qed

text {*
Definición. [Ejemplo de definición existencial]
El número natural x divide al número natural y si existe un natural k
tal que k×x = y. Se representa por x | y.
*}

definition divide :: "nat ⇒ nat ⇒ bool" ("_ | _" [80,80] 80) where
"x | y ≡ ∃k. k*x = y"

text {*
Ejemplo de activación automática de regla de simplificación:
La definición de divide se añade a las reglas de simplificación.
*}

declare divide_def[simp]

text {*
Lema. [Transitividad de la divisibilidad]
Sean a, b y c números naturales. Si b es divisible por a y c es
divisible por b, entonces c es divisible por a.
*}

lemma divide_trans:
fixes a b c :: "nat"
assumes ab: "a | b" and bc: "b | c"
shows "a | c"
proof simp
from ab obtain m where m: "m*a = b" by auto
from bc obtain n where n: "n*b = c" by auto
from m n have "m*n*a = c" by auto
thus "∃k. k*a = c" by (rule exI)
qed

text {*
Método auto: En el lema anterior es la primera vez que se usa el
método automático "auto".

Lema. [CNS de divisibilidad]
Sean a y b dos números naturales. Entonces a es divisible por b syss
el resto de dividir a entre b es cero.
*}

lemma CNS_divisibilidad:
"(a | b) = (b mod a = 0)"
by auto

section {* Razonamiento ecuacional *}

text {*
Elementos para el razonamiento ecuacional:
El razonamiento ecuacional se realiza de manera más concisa usando la
combinación de "also" (además) y "finally" (finalmente).

Lema. [Ejemplo de razonamiento ecuacional]
Si a=b, b=c y c=d, entonces a=d.
*}

lemma
assumes 1: "a = b" and 2: "b = c" and 3: "c = d"
shows "a = d"
proof -
have "a = b" by (rule 1)
also have "… = c" by (rule 2)
also have "… = d" by (rule 3)
finally show "a = d" .
qed

text {*
El lema anterior puede demostrarse automáticamente con la maza
("sledgehammer").
*}

lemma
assumes 1: "a = b" and 2: "b = c" and 3: "c = d"
shows "a = d"
proof -
show "a=d" by (metis 1 2 3)
qed

end
</source>

DAO2011 (Demostración asistida por ordenador)

2012-01-31T09:44:34Z

Jalonso: /* Razonamiento automático (2011-12) */

Tema 6: Isabelle como un lenguaje funcional

2012-01-19T15:00:59Z

Jalonso:

<source lang="isar">
header {* Tema 6: Isabelle como un lenguaje funcional *}

theory Tema_6
imports Main
begin

section {* Introducción *}

text {*
Esta notas son una introducción a la demostración asistida utilizando
el sistema Isabelle/HOL/Isar.

La versión de Isabelle utilizada es la 2011.

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.

El ejemplo del lema más trivial es el siguiente
*}

lemma elMasTrivial: "True"
by simp

text {*
En este capítulos se presenta el lenguaje funcional que está incluido en
Isabelle.

El lenguaje funcional es muy parecido al ML estándard.
*}

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 n" (el sucesor de n).

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.

Lema [Ejemplo de simplificación de números naturales]
El siguiente del 0 es el 1.
*}

lemma "Suc 0 = 1"
by simp

text {*
En Isabelle están definida la suma y el producto de números naturales:
· "x+y" es la suma de x e y
· "x*y" es el producto de x e y

Lema [Ejemplo de suma]
La suma de los números naturales 1 y 2 es el número natural 3.
*}

lemma "1 + 2 = (3::nat)"
by simp

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

Lema [Ejemplo de producto]
El producto de los números naturales 2 y 3 es el número natural 6.
*}

lemma "2 * 3 = (6::nat)"
by simp

text {*
En Isabelle está definida la división de números naturales:
· "n div m" es el cociente entero de n entre "m"
· "n mod m" es el resto de dividir "n" entre "m".

Lema [Ejemplo de división]
La división natural de 7 entre 3 es 2.
*}

lemma "7 div 3 = (2::nat)"
by simp

text {*
Lema [Ejemplo de resto]
El resto de dividir 7 entre 3 es 1.
*}

lemma "7 mod 3 = (1::nat)"
by simp

text {*
En Isabelle también están definidos los números enteros.

El tipo de los enteros se representa por int.

Lema [Ejemplo de operación con enteros]
La suma de 1 y -2 es el número entero -1.
*}

lemma "1 + -2 = (-1::int)"
by simp

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, False",
· las conectivas "¬, ∧, ∨, ⟶, ↔" y
· los cuantificadores "∀, ∃".

El tipo de los booleanos es bool.

Lema [Ejemplos de evaluaciones booleanas]
· La conjunción de dos fórmulas verdaderas es verdadera.
· La conjunción de un fórmula verdadera y una falsa es falsa.
· La disyunción de una fórmula verdadera y una falsa es verdadera.
· La disyunción de dos fórmulas falsas es falsa.
· La negación de una fórmula verdadera es falsa.
· Una fórmula falsa implica una fórmula verdadera.
· Todo elemento es igual a sí mismo.
· Existe un elemento igual a 1.
*}

lemma "True ∧ True = True"
by simp

lemma "True ∧ False = False"
by simp

lemma "True ∨ False = True"
by simp

lemma "False ∨ False = False"
by simp

lemma "¬ True = (False::bool)"
by simp

lemma "False ⟶ True"
by simp

lemma "∀ x. x = x"
by simp

lemma "∃ x. x = 1"
by simp

section {* Definiciones no recursivas *}

text {*
Definición [Ejemplo de definición no recursiva]
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 {*
Lema [Ejemplo de demostración con definiciones no recursivas]
La disyunción exclusiva de dos fórmulas verdaderas es falsa.

Demostración. 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 exlusiva al conjunto de reglas de
simplificación automáticas.
*}

declare xor_def[simp]

section {* Definiciones locales *}

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

Lema [Ejemplo de entorno local]
Sea x el número natural 3. Entonces "x × x = 9".
*}

lemma "(let x = 3::nat in x * x = 9)"
by simp

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.

Lema [Ejemplo de uso de pares]
Sea p el par de números naturales (2,3). La suma del primer elemento de
p y 1 es igual al segundo elemento de p.
*}

lemma "let p = (2,3)::nat × nat in fst p + 1 = snd p"
by simp

section {* Listas *}

text {*
Una lista se representa escribiendo los elementos entre corchetes y separados
por coma.

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 a#l representa la lista obtenida añadiendo el elemento a al
principio de la lista l.

Lema [Ejemplo de construcción de listas]
La lista obtenida añadiendo sucesivamente a la lista vacía los elementos 3,
2 y 1 es [1,2,3].
*}

lemma "1#(2#(3#[])) = [1,2,3]"
by simp

text {*
(hd l) es el primer elemento de la lista l.

(tl l) es el resto de la lista l.

Lema [Ejemplo de cálculo con listas]
Sea l la lista de números naturales [1,2,3]. Entonces, el primero de l es 1 y
el resto de l es [2,3].
*}

lemma "let l = [1,2,3]::(nat list) in hd l = 1 ∧ tl l = [2,3]"
by simp

text {*
(length l)es la longitud de la lista l.

Lema [Ejemplo de cálculo de longitud]
La longitud de la lista [1,2,3] es 3.
*}

lemma "length [1,2,3] = 3"
by simp

text {*
En la sesión 38 de "HOL: The basis of Higher-Order Logic"
(en http://isabelle.informatik.tu-muenchen.de/library/HOL/outline.pdf)
se encuentran más definiciones y propiedades de las listas.
*}

section {* Registros *}

text {*
Un registro es una colección de campos y valores.

Definición [Ejemplo de definición de registro]
Los puntos del plano pueden representarse mediante registros con dos campos,
las coordenadas, con valores enteros.
*}

record punto =
coordenada_x :: int
coordenada_y :: int

text {*
Definición [Ejemplo de definición de un registro]
El punto pt tiene de coordenadas 3 y 7.
*}

definition pt :: punto where
"pt ≡ (|coordenada_x = 3, coordenada_y = 7|)"

text {*
Lema [Ejemplo de propiedad de registro]
La coordenada x del punto pt es 3.
*}

lemma "coordenada_x pt = 3"
by (simp add: pt_def)

text {*
Lema [Ejemplo de actualización de un registro]
Sea pt2 el punto obtenido a partir del punto pt cambiando el
valor de su coordenada x por 4. Entonces la coordenada x del punto pt2
es 4.
*}

lemma "let pt2=pt(|coordenada_x:=4|) in coordenada_x (pt2) = 4"
by (simp add: pt_def)

section {* Funciones anónimas *}

text {*
En Isabelle pueden definirse funciones anónimas.

Lema [Ejemplo de uso de funciones anónimas]
El valor de la función que a un número le asigna su doble aplicada a 1 es 2.
*}

lemma "(λ x. x + x) 1 = (2::nat)"
by simp

section {* Condicionales *}

text {*
Definición [Ejemplo con el condicional if]
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 {*
Lema [Ejemplo de simplificación con el condicional if]
El valor absoluto de -3 es 3.
*}

lemma "absoluto(-3) = 3"
by (simp add:absoluto_def)

text {*
Definición [Ejemplo con el condicional case]
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 {*
Lema [Ejemplo de simplificación con el condicional case]
El número 3 es sucesor.
*}

lemma "es_sucesor 3"
by (simp add: es_sucesor_def)

section {* Tipos de datos y recursión primitiva *}

text {*
Definición [Ejemplo de definición de tipo de dato recursivo]
Una lista de elementos de tipo a es la lista Vacia o se obtiene añadiendo,
con ConsLista, un elemento de tipo a a una lista de elementos de tipo a.
*}

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

text {*
Definición [Ejemplo de definición primitiva recursiva]
(conc xs ys) es la concatenación de las lista xs e ys.
*}

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

text {*
Lema [Ejemplo de simplificación con tipo de dato recursivo]
La concatenación de la lista formada por 1 y 2 con la lista formada por el 3
es la lista cuyos elementos son 1,2 y 3.
*}

lemma "conc (ConsLista 1 (ConsLista 2 Vacia)) (ConsLista 3 Vacia) =
(ConsLista 1 (ConsLista 2 (ConsLista 3 Vacia)))"
by simp

text {*
Ejercicio [Ejemplo de definición primitiva recursiva sobre los naturales]
Definir una función que sume los primeros n números naturales y usarla para
comprobar que la suma de los 3 primeros números naturales es 6.
*}

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

lemma "suma 3 = 6"
by (simp add: suma_def)

value "suma 3"
value "2+(3::int)"

end
</source>

Tema 6: Isabelle como un lenguaje funcional

2012-01-19T14:56:31Z

Jalonso:

<source lang="isar">
header {* Tema 6: Isabelle como un lenguaje funcional *}

theory Tema_6
imports Main
begin

section {* Introducción *}

text {*
Esta notas son una introducción a la demostración asistida utilizando
el sistema Isabelle/HOL/Isar.

La versión de Isabelle utilizada es la 2011.

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. El ejemplo del lema más trivial es el siguiente *}
*}

lemma elMasTrivial: "True"
by simp

text {*
En este capítulos se presenta el lenguaje funcional que está incluido en
Isabelle.

El lenguaje funcional es muy parecido al ML estándard.
*}

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 n" (el sucesor de n).

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.

Lema [Ejemplo de simplificación de números naturales]
El siguiente del 0 es el 1.
*}

lemma "Suc 0 = 1"
by simp

text {*
En Isabelle están definida la suma y el producto de números naturales:
· "x+y" es la suma de x e y
· "x*y" es el producto de x e y

Lema [Ejemplo de suma]
La suma de los números naturales 1 y 2 es el número natural 3.
*}

lemma "1 + 2 = (3::nat)"
by simp

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

Lema [Ejemplo de producto]
El producto de los números naturales 2 y 3 es el número natural 6.
*}

lemma "2 * 3 = (6::nat)"
by simp

text {*
En Isabelle está definida la división de números naturales:
· "n div m" es el cociente entero de n entre "m"
· "n mod m" es el resto de dividir "n" entre "m".

Lema [Ejemplo de división]
La división natural de 7 entre 3 es 2.
*}

lemma "7 div 3 = (2::nat)"
by simp

text {*
Lema [Ejemplo de resto]
El resto de dividir 7 entre 3 es 1.
*}

lemma "7 mod 3 = (1::nat)"
by simp

text {*
En Isabelle también están definidos los números enteros.

El tipo de los enteros se representa por int.

Lema [Ejemplo de operación con enteros]
La suma de 1 y -2 es el número entero -1.
*}

lemma "1 + -2 = (-1::int)"
by simp

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, False",
· las conectivas "¬, ∧, ∨, ⟶, ↔" y
· los cuantificadores "∀, ∃".

El tipo de los booleanos es bool.

Lema [Ejemplos de evaluaciones booleanas]
· La conjunción de dos fórmulas verdaderas es verdadera.
· La conjunción de un fórmula verdadera y una falsa es falsa.
· La disyunción de una fórmula verdadera y una falsa es verdadera.
· La disyunción de dos fórmulas falsas es falsa.
· La negación de una fórmula verdadera es falsa.
· Una fórmula falsa implica una fórmula verdadera.
· Todo elemento es igual a sí mismo.
· Existe un elemento igual a 1.
*}

lemma "True ∧ True = True"
by simp

lemma "True ∧ False = False"
by simp

lemma "True ∨ False = True"
by simp

lemma "False ∨ False = False"
by simp

lemma "¬ True = (False::bool)"
by simp

lemma "False ⟶ True"
by simp

lemma "∀ x. x = x"
by simp

lemma "∃ x. x = 1"
by simp

section {* Definiciones no recursivas *}

text {*
Definición [Ejemplo de definición no recursiva]
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 {*
Lema [Ejemplo de demostración con definiciones no recursivas]
La disyunción exclusiva de dos fórmulas verdaderas es falsa.

Demostración. 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 exlusiva al conjunto de reglas de
simplificación automáticas.
*}

declare xor_def[simp]

section {* Definiciones locales *}

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

Lema [Ejemplo de entorno local]
Sea x el número natural 3. Entonces "x × x = 9".
*}

lemma "(let x = 3::nat in x * x = 9)"
by simp

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.

Lema [Ejemplo de uso de pares]
Sea p el par de números naturales (2,3). La suma del primer elemento de
p y 1 es igual al segundo elemento de p.
*}

lemma "let p = (2,3)::nat × nat in fst p + 1 = snd p"
by simp

section {* Listas *}

text {*
Una lista se representa escribiendo los elementos entre corchetes y separados
por coma.

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 a#l representa la lista obtenida añadiendo el elemento a al
principio de la lista l.

Lema [Ejemplo de construcción de listas]
La lista obtenida añadiendo sucesivamente a la lista vacía los elementos 3,
2 y 1 es [1,2,3].
*}

lemma "1#(2#(3#[])) = [1,2,3]"
by simp

text {*
(hd l) es el primer elemento de la lista l.

(tl l) es el resto de la lista l.

Lema [Ejemplo de cálculo con listas]
Sea l la lista de números naturales [1,2,3]. Entonces, el primero de l es 1 y
el resto de l es [2,3].
*}

lemma "let l = [1,2,3]::(nat list) in hd l = 1 ∧ tl l = [2,3]"
by simp

text {*
(length l)es la longitud de la lista l.

Lema [Ejemplo de cálculo de longitud]
La longitud de la lista [1,2,3] es 3.
*}

lemma "length [1,2,3] = 3"
by simp

text {*
En la sesión 38 de "HOL: The basis of Higher-Order Logic"
(en http://isabelle.informatik.tu-muenchen.de/library/HOL/outline.pdf)
se encuentran más definiciones y propiedades de las listas.
*}

section {* Registros *}

text {*
Un registro es una colección de campos y valores.

Definición [Ejemplo de definición de registro]
Los puntos del plano pueden representarse mediante registros con dos campos,
las coordenadas, con valores enteros.
*}

record punto =
coordenada_x :: int
coordenada_y :: int

text {*
Definición [Ejemplo de definición de un registro]
El punto pt tiene de coordenadas 3 y 7.
*}

definition pt :: punto where
"pt ≡ (|coordenada_x = 3, coordenada_y = 7|)"

text {*
Lema [Ejemplo de propiedad de registro]
La coordenada x del punto pt es 3.
*}

lemma "coordenada_x pt = 3"
by (simp add: pt_def)

text {*
Lema [Ejemplo de actualización de un registro]
Sea pt2 el punto obtenido a partir del punto pt cambiando el
valor de su coordenada x por 4. Entonces la coordenada x del punto pt2
es 4.
*}

lemma "let pt2=pt(|coordenada_x:=4|) in coordenada_x (pt2) = 4"
by (simp add: pt_def)

section {* Funciones anónimas *}

text {*
En Isabelle pueden definirse funciones anónimas.

Lema [Ejemplo de uso de funciones anónimas]
El valor de la función que a un número le asigna su doble aplicada a 1 es 2.
*}

lemma "(λ x. x + x) 1 = (2::nat)"
by simp

section {* Condicionales *}

text {*
Definición [Ejemplo con el condicional if]
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 {*
Lema [Ejemplo de simplificación con el condicional if]
El valor absoluto de -3 es 3.
*}

lemma "absoluto(-3) = 3"
by (simp add:absoluto_def)

text {*
Definición [Ejemplo con el condicional case]
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 {*
Lema [Ejemplo de simplificación con el condicional case]
El número 3 es sucesor.
*}

lemma "es_sucesor 3"
by (simp add: es_sucesor_def)

section {* Tipos de datos y recursión primitiva *}

text {*
Definición [Ejemplo de definición de tipo de dato recursivo]
Una lista de elementos de tipo a es la lista Vacia o se obtiene añadiendo,
con ConsLista, un elemento de tipo a a una lista de elementos de tipo a.
*}

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

text {*
Definición [Ejemplo de definición primitiva recursiva]
(conc xs ys) es la concatenación de las lista xs e ys.
*}

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

text {*
Lema [Ejemplo de simplificación con tipo de dato recursivo]
La concatenación de la lista formada por 1 y 2 con la lista formada por el 3
es la lista cuyos elementos son 1,2 y 3.
*}

lemma "conc (ConsLista 1 (ConsLista 2 Vacia)) (ConsLista 3 Vacia) =
(ConsLista 1 (ConsLista 2 (ConsLista 3 Vacia)))"
by simp

text {*
Ejercicio [Ejemplo de definición primitiva recursiva sobre los naturales]
Definir una función que sume los primeros n números naturales y usarla para
comprobar que la suma de los 3 primeros números naturales es 6.
*}

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

lemma "suma 3 = 6"
by (simp add: suma_def)

value "suma 3"
value "2+(3::int)"

end
</source>

Tema 6: Isabelle como un lenguaje funcional

2012-01-19T14:55:27Z

Jalonso:

<source lang="isar">
header {* Tema 6: Isabelle como un lenguaje funcional *}

theory Tema_6
imports Main
begin

section {* Introducción *}

text {*
Esta notas son una introducción a la demostración asistida utilizando
el sistema Isabelle/HOL/Isar.

La versión de Isabelle utilizada es la 2011.

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. El ejemplo del lema más trivial es el siguiente *}
*}

lemma elMasTrivial: "True"
by simp

text {*
En este capítulos se presenta el lenguaje funcional que está incluido en
Isabelle.

El lenguaje funcional es muy parecido al ML estándard.
*}

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 n" (el sucesor de n).

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.

Lema [Ejemplo de simplificación de números naturales]
El siguiente del 0 es el 1.
*}

lemma "Suc 0 = 1"
by simp

text {*
En Isabelle están definida la suma y el producto de números naturales:
· "x+y" es la suma de x e y
· "x*y" es el producto de x e y

Lema [Ejemplo de suma]
La suma de los números naturales 1 y 2 es el número natural 3.
*}

lemma "1 + 2 = (3::nat)"
by simp

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

Lema [Ejemplo de producto]
El producto de los números naturales 2 y 3 es el número natural 6.
*}

lemma "2 * 3 = (6::nat)"
by simp

text {*
En Isabelle está definida la división de números naturales:
· "n div m" es el cociente entero de n entre "m"
· "n mod m" es el resto de dividir "n" entre "m".

Lema [Ejemplo de división]
La división natural de 7 entre 3 es 2.
*}

lemma "7 div 3 = (2::nat)"
by simp

text {*
Lema [Ejemplo de resto]
El resto de dividir 7 entre 3 es 1.
*}

lemma "7 mod 3 = (1::nat)"
by simp

text {*
En Isabelle también están definidos los números enteros.

El tipo de los enteros se representa por int.

Lema [Ejemplo de operación con enteros]
La suma de 1 y -2 es el número entero -1.
*}

lemma "1 + -2 = (-1::int)"
by simp

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, False",
· las conectivas "\<not>, \<and>, \<or>, \<longrightarrow>, \<leftrightarrow>" y
· los cuantificadores "\<forall>, \<exists>".

El tipo de los booleanos es bool.

Lema [Ejemplos de evaluaciones booleanas]
· La conjunción de dos fórmulas verdaderas es verdadera.
· La conjunción de un fórmula verdadera y una falsa es falsa.
· La disyunción de una fórmula verdadera y una falsa es verdadera.
· La disyunción de dos fórmulas falsas es falsa.
· La negación de una fórmula verdadera es falsa.
· Una fórmula falsa implica una fórmula verdadera.
· Todo elemento es igual a sí mismo.
· Existe un elemento igual a 1.
*}

lemma "True \<and> True = True"
by simp

lemma "True \<and> False = False"
by simp

lemma "True \<or> False = True"
by simp

lemma "False \<or> False = False"
by simp

lemma "\<not> True = (False::bool)"
by simp

lemma "False \<longrightarrow> True"
by simp

lemma "\<forall> x. x = x"
by simp

lemma "\<exists> x. x = 1"
by simp

section {* Definiciones no recursivas *}

text {*
Definición [Ejemplo de definición no recursiva]
La disyunción exclusiva de A y B se verifica si una es verdadera y la
otra no lo es.
*}

definition xor :: "bool \<Rightarrow> bool \<Rightarrow> bool" where
"xor A B \<equiv> (A \<and> \<not> B) \<or> (\<not> A \<and> B)"

text {*
Lema [Ejemplo de demostración con definiciones no recursivas]
La disyunción exclusiva de dos fórmulas verdaderas es falsa.

Demostración. 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 exlusiva al conjunto de reglas de
simplificación automáticas.
*}

declare xor_def[simp]

section {* Definiciones locales *}

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

Lema [Ejemplo de entorno local]
Sea x el número natural 3. Entonces "x \<times> x = 9".
*}

lemma "(let x = 3::nat in x * x = 9)"
by simp

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.

Lema [Ejemplo de uso de pares]
Sea p el par de números naturales (2,3). La suma del primer elemento de
p y 1 es igual al segundo elemento de p.
*}

lemma "let p = (2,3)::nat \<times> nat in fst p + 1 = snd p"
by simp

section {* Listas *}

text {*
Una lista se representa escribiendo los elementos entre corchetes y separados
por coma.

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 a#l representa la lista obtenida añadiendo el elemento a al
principio de la lista l.

Lema [Ejemplo de construcción de listas]
La lista obtenida añadiendo sucesivamente a la lista vacía los elementos 3,
2 y 1 es [1,2,3].
*}

lemma "1#(2#(3#[])) = [1,2,3]"
by simp

text {*
(hd l) es el primer elemento de la lista l.

(tl l) es el resto de la lista l.

Lema [Ejemplo de cálculo con listas]
Sea l la lista de números naturales [1,2,3]. Entonces, el primero de l es 1 y
el resto de l es [2,3].
*}

lemma "let l = [1,2,3]::(nat list) in hd l = 1 \<and> tl l = [2,3]"
by simp

text {*
(length l)es la longitud de la lista l.

Lema [Ejemplo de cálculo de longitud]
La longitud de la lista [1,2,3] es 3.
*}

lemma "length [1,2,3] = 3"
by simp

text {*
En la sesión 38 de "HOL: The basis of Higher-Order Logic"
(en http://isabelle.informatik.tu-muenchen.de/library/HOL/outline.pdf)
se encuentran más definiciones y propiedades de las listas.
*}

section {* Registros *}

text {*
Un registro es una colección de campos y valores.

Definición [Ejemplo de definición de registro]
Los puntos del plano pueden representarse mediante registros con dos campos,
las coordenadas, con valores enteros.
*}

record punto =
coordenada_x :: int
coordenada_y :: int

text {*
Definición [Ejemplo de definición de un registro]
El punto pt tiene de coordenadas 3 y 7.
*}

definition pt :: punto where
"pt \<equiv> \<lparr>coordenada_x = 3, coordenada_y = 7\<rparr>"

text {*
Lema [Ejemplo de propiedad de registro]
La coordenada x del punto pt es 3.
*}

lemma "coordenada_x pt = 3"
by (simp add: pt_def)

text {*
Lema [Ejemplo de actualización de un registro]
Sea pt2 el punto obtenido a partir del punto pt cambiando el
valor de su coordenada x por 4. Entonces la coordenada x del punto pt2
es 4.
*}

lemma "let pt2=pt\<lparr>coordenada_x:=4\<rparr> in coordenada_x (pt2) = 4"
by (simp add: pt_def)

section {* Funciones anónimas *}

text {*
En Isabelle pueden definirse funciones anónimas.

Lema [Ejemplo de uso de funciones anónimas]
El valor de la función que a un número le asigna su doble aplicada a 1 es 2.
*}

lemma "(\<lambda> x. x + x) 1 = (2::nat)"
by simp

section {* Condicionales *}

text {*
Definición [Ejemplo con el condicional if]
El valor absoluto del entero x es x, si "x \<ge> 0" y es -x en caso
contrario.
*}

definition absoluto :: "int \<Rightarrow> int" where
"absoluto x \<equiv> (if x \<ge> 0 then x else -x)"

text {*
Lema [Ejemplo de simplificación con el condicional if]
El valor absoluto de -3 es 3.
*}

lemma "absoluto(-3) = 3"
by (simp add:absoluto_def)

text {*
Definición [Ejemplo con el condicional case]
Un número natural n es un sucesor si es de la forma "Suc m".
*}

definition es_sucesor :: "nat \<Rightarrow> bool" where
"es_sucesor n \<equiv>
(case n of
0 \<Rightarrow> False
| Suc m \<Rightarrow> True)"

text {*
Lema [Ejemplo de simplificación con el condicional case]
El número 3 es sucesor.
*}

lemma "es_sucesor 3"
by (simp add: es_sucesor_def)

section {* Tipos de datos y recursión primitiva *}

text {*
Definición [Ejemplo de definición de tipo de dato recursivo]
Una lista de elementos de tipo a es la lista Vacia o se obtiene añadiendo,
con ConsLista, un elemento de tipo a a una lista de elementos de tipo a.
*}

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

text {*
Definición [Ejemplo de definición primitiva recursiva]
(conc xs ys) es la concatenación de las lista xs e ys.
*}

primrec conc :: "'a Lista \<Rightarrow> 'a Lista \<Rightarrow> 'a Lista" where
"conc Vacia ys = ys"
| "conc (ConsLista x xs) ys = ConsLista x (conc xs ys)"

text {*
Lema [Ejemplo de simplificación con tipo de dato recursivo]
La concatenación de la lista formada por 1 y 2 con la lista formada por el 3
es la lista cuyos elementos son 1,2 y 3.
*}

lemma "conc (ConsLista 1 (ConsLista 2 Vacia)) (ConsLista 3 Vacia) =
(ConsLista 1 (ConsLista 2 (ConsLista 3 Vacia)))"
by simp

text {*
Ejercicio [Ejemplo de definición primitiva recursiva sobre los naturales]
Definir una función que sume los primeros n números naturales y usarla para
comprobar que la suma de los 3 primeros números naturales es 6.
*}

primrec suma :: "nat \<Rightarrow> nat" where
"suma 0 = 0"
| "suma (Suc m) = (Suc m) + suma m"

lemma "suma 3 = 6"
by (simp add: suma_def)

value "suma 3"
value "2+(3::int)"

end
</source>

Tema 6: Isabelle como un lenguaje funcional

2012-01-19T14:54:42Z

Jalonso: Página creada con '<source lang="isabelle"> header {* Tema 6: Isabelle como un lenguaje funcional *} theory Tema_6 imports Main begin section {* Introducción *} text {* Esta notas son una in...'

<source lang="isabelle">
header {* Tema 6: Isabelle como un lenguaje funcional *}

theory Tema_6
imports Main
begin

section {* Introducción *}

text {*
Esta notas son una introducción a la demostración asistida utilizando
el sistema Isabelle/HOL/Isar.

La versión de Isabelle utilizada es la 2011.

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. El ejemplo del lema más trivial es el siguiente *}
*}

lemma elMasTrivial: "True"
by simp

text {*
En este capítulos se presenta el lenguaje funcional que está incluido en
Isabelle.

El lenguaje funcional es muy parecido al ML estándard.
*}

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 n" (el sucesor de n).

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.

Lema [Ejemplo de simplificación de números naturales]
El siguiente del 0 es el 1.
*}

lemma "Suc 0 = 1"
by simp

text {*
En Isabelle están definida la suma y el producto de números naturales:
· "x+y" es la suma de x e y
· "x*y" es el producto de x e y

Lema [Ejemplo de suma]
La suma de los números naturales 1 y 2 es el número natural 3.
*}

lemma "1 + 2 = (3::nat)"
by simp

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

Lema [Ejemplo de producto]
El producto de los números naturales 2 y 3 es el número natural 6.
*}

lemma "2 * 3 = (6::nat)"
by simp

text {*
En Isabelle está definida la división de números naturales:
· "n div m" es el cociente entero de n entre "m"
· "n mod m" es el resto de dividir "n" entre "m".

Lema [Ejemplo de división]
La división natural de 7 entre 3 es 2.
*}

lemma "7 div 3 = (2::nat)"
by simp

text {*
Lema [Ejemplo de resto]
El resto de dividir 7 entre 3 es 1.
*}

lemma "7 mod 3 = (1::nat)"
by simp

text {*
En Isabelle también están definidos los números enteros.

El tipo de los enteros se representa por int.

Lema [Ejemplo de operación con enteros]
La suma de 1 y -2 es el número entero -1.
*}

lemma "1 + -2 = (-1::int)"
by simp

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, False",
· las conectivas "\<not>, \<and>, \<or>, \<longrightarrow>, \<leftrightarrow>" y
· los cuantificadores "\<forall>, \<exists>".

El tipo de los booleanos es bool.

Lema [Ejemplos de evaluaciones booleanas]
· La conjunción de dos fórmulas verdaderas es verdadera.
· La conjunción de un fórmula verdadera y una falsa es falsa.
· La disyunción de una fórmula verdadera y una falsa es verdadera.
· La disyunción de dos fórmulas falsas es falsa.
· La negación de una fórmula verdadera es falsa.
· Una fórmula falsa implica una fórmula verdadera.
· Todo elemento es igual a sí mismo.
· Existe un elemento igual a 1.
*}

lemma "True \<and> True = True"
by simp

lemma "True \<and> False = False"
by simp

lemma "True \<or> False = True"
by simp

lemma "False \<or> False = False"
by simp

lemma "\<not> True = (False::bool)"
by simp

lemma "False \<longrightarrow> True"
by simp

lemma "\<forall> x. x = x"
by simp

lemma "\<exists> x. x = 1"
by simp

section {* Definiciones no recursivas *}

text {*
Definición [Ejemplo de definición no recursiva]
La disyunción exclusiva de A y B se verifica si una es verdadera y la
otra no lo es.
*}

definition xor :: "bool \<Rightarrow> bool \<Rightarrow> bool" where
"xor A B \<equiv> (A \<and> \<not> B) \<or> (\<not> A \<and> B)"

text {*
Lema [Ejemplo de demostración con definiciones no recursivas]
La disyunción exclusiva de dos fórmulas verdaderas es falsa.

Demostración. 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 exlusiva al conjunto de reglas de
simplificación automáticas.
*}

declare xor_def[simp]

section {* Definiciones locales *}

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

Lema [Ejemplo de entorno local]
Sea x el número natural 3. Entonces "x \<times> x = 9".
*}

lemma "(let x = 3::nat in x * x = 9)"
by simp

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.

Lema [Ejemplo de uso de pares]
Sea p el par de números naturales (2,3). La suma del primer elemento de
p y 1 es igual al segundo elemento de p.
*}

lemma "let p = (2,3)::nat \<times> nat in fst p + 1 = snd p"
by simp

section {* Listas *}

text {*
Una lista se representa escribiendo los elementos entre corchetes y separados
por coma.

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 a#l representa la lista obtenida añadiendo el elemento a al
principio de la lista l.

Lema [Ejemplo de construcción de listas]
La lista obtenida añadiendo sucesivamente a la lista vacía los elementos 3,
2 y 1 es [1,2,3].
*}

lemma "1#(2#(3#[])) = [1,2,3]"
by simp

text {*
(hd l) es el primer elemento de la lista l.

(tl l) es el resto de la lista l.

Lema [Ejemplo de cálculo con listas]
Sea l la lista de números naturales [1,2,3]. Entonces, el primero de l es 1 y
el resto de l es [2,3].
*}

lemma "let l = [1,2,3]::(nat list) in hd l = 1 \<and> tl l = [2,3]"
by simp

text {*
(length l)es la longitud de la lista l.

Lema [Ejemplo de cálculo de longitud]
La longitud de la lista [1,2,3] es 3.
*}

lemma "length [1,2,3] = 3"
by simp

text {*
En la sesión 38 de "HOL: The basis of Higher-Order Logic"
(en http://isabelle.informatik.tu-muenchen.de/library/HOL/outline.pdf)
se encuentran más definiciones y propiedades de las listas.
*}

section {* Registros *}

text {*
Un registro es una colección de campos y valores.

Definición [Ejemplo de definición de registro]
Los puntos del plano pueden representarse mediante registros con dos campos,
las coordenadas, con valores enteros.
*}

record punto =
coordenada_x :: int
coordenada_y :: int

text {*
Definición [Ejemplo de definición de un registro]
El punto pt tiene de coordenadas 3 y 7.
*}

definition pt :: punto where
"pt \<equiv> \<lparr>coordenada_x = 3, coordenada_y = 7\<rparr>"

text {*
Lema [Ejemplo de propiedad de registro]
La coordenada x del punto pt es 3.
*}

lemma "coordenada_x pt = 3"
by (simp add: pt_def)

text {*
Lema [Ejemplo de actualización de un registro]
Sea pt2 el punto obtenido a partir del punto pt cambiando el
valor de su coordenada x por 4. Entonces la coordenada x del punto pt2
es 4.
*}

lemma "let pt2=pt\<lparr>coordenada_x:=4\<rparr> in coordenada_x (pt2) = 4"
by (simp add: pt_def)

section {* Funciones anónimas *}

text {*
En Isabelle pueden definirse funciones anónimas.

Lema [Ejemplo de uso de funciones anónimas]
El valor de la función que a un número le asigna su doble aplicada a 1 es 2.
*}

lemma "(\<lambda> x. x + x) 1 = (2::nat)"
by simp

section {* Condicionales *}

text {*
Definición [Ejemplo con el condicional if]
El valor absoluto del entero x es x, si "x \<ge> 0" y es -x en caso
contrario.
*}

definition absoluto :: "int \<Rightarrow> int" where
"absoluto x \<equiv> (if x \<ge> 0 then x else -x)"

text {*
Lema [Ejemplo de simplificación con el condicional if]
El valor absoluto de -3 es 3.
*}

lemma "absoluto(-3) = 3"
by (simp add:absoluto_def)

text {*
Definición [Ejemplo con el condicional case]
Un número natural n es un sucesor si es de la forma "Suc m".
*}

definition es_sucesor :: "nat \<Rightarrow> bool" where
"es_sucesor n \<equiv>
(case n of
0 \<Rightarrow> False
| Suc m \<Rightarrow> True)"

text {*
Lema [Ejemplo de simplificación con el condicional case]
El número 3 es sucesor.
*}

lemma "es_sucesor 3"
by (simp add: es_sucesor_def)

section {* Tipos de datos y recursión primitiva *}

text {*
Definición [Ejemplo de definición de tipo de dato recursivo]
Una lista de elementos de tipo a es la lista Vacia o se obtiene añadiendo,
con ConsLista, un elemento de tipo a a una lista de elementos de tipo a.
*}

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

text {*
Definición [Ejemplo de definición primitiva recursiva]
(conc xs ys) es la concatenación de las lista xs e ys.
*}

primrec conc :: "'a Lista \<Rightarrow> 'a Lista \<Rightarrow> 'a Lista" where
"conc Vacia ys = ys"
| "conc (ConsLista x xs) ys = ConsLista x (conc xs ys)"

text {*
Lema [Ejemplo de simplificación con tipo de dato recursivo]
La concatenación de la lista formada por 1 y 2 con la lista formada por el 3
es la lista cuyos elementos son 1,2 y 3.
*}

lemma "conc (ConsLista 1 (ConsLista 2 Vacia)) (ConsLista 3 Vacia) =
(ConsLista 1 (ConsLista 2 (ConsLista 3 Vacia)))"
by simp

text {*
Ejercicio [Ejemplo de definición primitiva recursiva sobre los naturales]
Definir una función que sume los primeros n números naturales y usarla para
comprobar que la suma de los 3 primeros números naturales es 6.
*}

primrec suma :: "nat \<Rightarrow> nat" where
"suma 0 = 0"
| "suma (Suc m) = (Suc m) + suma m"

lemma "suma 3 = 6"
by (simp add: suma_def)

value "suma 3"
value "2+(3::int)"

end
</source>

DAO2011 (Demostración asistida por ordenador)

2012-01-19T14:53:43Z

Jalonso:

Ejercicios del tema 3

2011-03-29T11:49:08Z

Jalonso:

<source lang="isar">
header {* Deducción natural proposicional *}

theory Tema_3_ej
imports Main
begin

text {* Los ejercicios de esta relación deben de resolverse usando sólo
las reglas básicas de la deducción natural proposicional:
· 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
*}

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

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

lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
oops

lemma ejercicio_2:
assumes 1: "p⟶q" and
2: "q⟶r" and
3: "p"
shows "r"
oops

lemma ejercicio_3:
assumes 1: "p⟶(q⟶r)" and
2: "p⟶q" and
3: "p"
shows "r"
oops

lemma ejercicio_4:
assumes 1: "p⟶q" and
2: "q⟶r"
shows "p⟶r"
oops

lemma ejercicio_5:
"p⟶(q⟶r) ⟹ q⟶(p⟶r)"
oops

lemma ejercicio_6:
"p⟶(q⟶r) ⟹ (p⟶q)⟶(p⟶r)"
oops

lemma ejercicio_7:
"p ⟹ q⟶p"
oops

lemma ejercicio_8:
"p⟶(q⟶p)"
oops

lemma ejercicio_9:
"p⟶q ⟹ (q⟶r)⟶(p⟶r)"
oops

lemma ejercicio_10:
"p⟶(q⟶(r⟶s)) ⟹ r⟶(q⟶(p⟶s))"
oops

lemma ejercicio_11:
"(p⟶(q⟶r))⟶((p⟶q)⟶(p⟶r))"
oops

lemma ejercicio_12:
"(p⟶q)⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_13:
"⟦p; q⟧ ⟹ p∧q"
oops

lemma ejercicio_14:
"p∧q ⟹ p"
oops

lemma ejercicio_15:
"p∧q ⟹ q"
oops

lemma ejercicio_16:
"p∧(q∧r) ⟹ (p∧q)∧r"
oops

lemma ejercicio_17:
"(p∧q)∧r ⟹ p∧(q∧r)"
oops

lemma ejercicio_18:
"p∧q ⟹ p⟶q"
oops

lemma ejercicio_19:
"(p⟶q)∧(p⟶r) ⟹ p⟶q∧r"
oops

lemma ejercicio_20:
"p⟶q∧r ⟹ (p⟶q)∧(p⟶r)"
oops

lemma ejercicio_21:
"p⟶(q⟶r) ⟹ p∧q⟶r"
oops

lemma ejercicio_22:
"p∧q⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_23:
"(p⟶q)⟶r ⟹ p∧q⟶r"
oops

lemma ejercicio_24:
"p∧(q⟶r) ⟹ (p⟶q)⟶r"
oops

lemma ejercicio_25:
"p ⟹ p∨q"
oops

lemma ejercicio_26:
"q ⟹ p∨q"
oops

lemma ejercicio_27:
"p∨q ⟹ q∨p"
oops

lemma ejercicio_28:
"q⟶r ⟹ p∨q⟶p∨r"
oops

lemma ejercicio_29:
"p∨p ⟹ p"
oops

lemma ejercicio_30:
"p ⟹ p∨p"
oops

lemma ejercicio_31:
"p∨(q∨r) ⟹ (p∨q)∨r"
oops

lemma ejercicio_32:
"(p∨q)∨r ⟹ p∨(q∨r)"
oops

lemma ejercicio_33:
"p∧(q∨r) ⟹ (p∧q)∨(p∧r)"
oops

lemma ejercicio_34:
"(p∧q)∨(p∧r) ⟹ p∧(q∨r)"
oops

lemma ejercicio_35:
"p∨(q∧r) ⟹ (p∨q)∧(p∨r)"
oops

lemma ejercicio_36:
"(p∨q)∧(p∨r) ⟹ p∨(q∧r)"
oops

lemma ejercicio_37:
"(p⟶r)∧(q⟶r) ⟹ p∨q⟶r"
oops

lemma ejercicio_38:
"p∨q⟶r ⟹ (p⟶r)∧(q⟶r)"
oops

lemma ejercicio_39:
"p ⟹ ¬¬p"
oops

lemma ejercicio_40:
"¬p ⟹ p⟶q"
oops

lemma ejercicio_41:
"p⟶q ⟹ ¬q⟶¬p"
oops

lemma ejercicio_42:
"⟦p∨q; ¬q⟧ ⟹ p"
oops

lemma ejercicio_43:
"⟦p∨q; ¬p⟧ ⟹ q"
oops

lemma ejercicio_44:
"p∨q ⟹ ¬(¬p∧¬q)"
oops

lemma ejercicio_45:
"p∧q ⟹ ¬(¬p∨¬q)"
oops

lemma ejercicio_46:
"¬(p∨q) ⟹ ¬p∧¬q"
oops

lemma ejercicio_47:
"¬p∧¬q ⟹ ¬(p∨q)"
oops

lemma ejercicio_48:
"¬p∨¬q ⟹ ¬(p∧q)"
oops

lemma ejercicio_49:
"¬(p∧¬p)"
oops

lemma ejercicio_50:
"p∧¬p ⟹ q"
oops

lemma ejercicio_51:
"¬¬p ⟹ p"
oops

lemma ejercicio_52:
"p∨¬p"
oops

lemma ejercicio_53:
"((p⟶q)⟶p)⟶p"
oops

lemma ejercicio_54:
"¬q⟶¬p ⟹ p⟶q"
oops

lemma ejercicio_55:
"¬(¬p∧¬q) ⟹ p∨q"
oops

lemma ejercicio_56:
"¬(¬p∨¬q) ⟹ p∧q"
oops

lemma ejercicio_57:
"¬(p∧q) ⟹ ¬p∨¬q"
oops

lemma ejercicio_58:"(p⟶q)∨(q⟶p)"
oops

end
</source>

Ejercicios del tema 3

2011-03-29T11:48:53Z

Jalonso: Página creada con '<source language="isar"> header {* Deducción natural proposicional *} theory Tema_3_ej imports Main begin text {* Los ejercicios de esta relación deben de resolverse usand...'

<source language="isar">
header {* Deducción natural proposicional *}

theory Tema_3_ej
imports Main
begin

text {* Los ejercicios de esta relación deben de resolverse usando sólo
las reglas básicas de la deducción natural proposicional:
· 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
*}

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

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

lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
oops

lemma ejercicio_2:
assumes 1: "p⟶q" and
2: "q⟶r" and
3: "p"
shows "r"
oops

lemma ejercicio_3:
assumes 1: "p⟶(q⟶r)" and
2: "p⟶q" and
3: "p"
shows "r"
oops

lemma ejercicio_4:
assumes 1: "p⟶q" and
2: "q⟶r"
shows "p⟶r"
oops

lemma ejercicio_5:
"p⟶(q⟶r) ⟹ q⟶(p⟶r)"
oops

lemma ejercicio_6:
"p⟶(q⟶r) ⟹ (p⟶q)⟶(p⟶r)"
oops

lemma ejercicio_7:
"p ⟹ q⟶p"
oops

lemma ejercicio_8:
"p⟶(q⟶p)"
oops

lemma ejercicio_9:
"p⟶q ⟹ (q⟶r)⟶(p⟶r)"
oops

lemma ejercicio_10:
"p⟶(q⟶(r⟶s)) ⟹ r⟶(q⟶(p⟶s))"
oops

lemma ejercicio_11:
"(p⟶(q⟶r))⟶((p⟶q)⟶(p⟶r))"
oops

lemma ejercicio_12:
"(p⟶q)⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_13:
"⟦p; q⟧ ⟹ p∧q"
oops

lemma ejercicio_14:
"p∧q ⟹ p"
oops

lemma ejercicio_15:
"p∧q ⟹ q"
oops

lemma ejercicio_16:
"p∧(q∧r) ⟹ (p∧q)∧r"
oops

lemma ejercicio_17:
"(p∧q)∧r ⟹ p∧(q∧r)"
oops

lemma ejercicio_18:
"p∧q ⟹ p⟶q"
oops

lemma ejercicio_19:
"(p⟶q)∧(p⟶r) ⟹ p⟶q∧r"
oops

lemma ejercicio_20:
"p⟶q∧r ⟹ (p⟶q)∧(p⟶r)"
oops

lemma ejercicio_21:
"p⟶(q⟶r) ⟹ p∧q⟶r"
oops

lemma ejercicio_22:
"p∧q⟶r ⟹ p⟶(q⟶r)"
oops

lemma ejercicio_23:
"(p⟶q)⟶r ⟹ p∧q⟶r"
oops

lemma ejercicio_24:
"p∧(q⟶r) ⟹ (p⟶q)⟶r"
oops

lemma ejercicio_25:
"p ⟹ p∨q"
oops

lemma ejercicio_26:
"q ⟹ p∨q"
oops

lemma ejercicio_27:
"p∨q ⟹ q∨p"
oops

lemma ejercicio_28:
"q⟶r ⟹ p∨q⟶p∨r"
oops

lemma ejercicio_29:
"p∨p ⟹ p"
oops

lemma ejercicio_30:
"p ⟹ p∨p"
oops

lemma ejercicio_31:
"p∨(q∨r) ⟹ (p∨q)∨r"
oops

lemma ejercicio_32:
"(p∨q)∨r ⟹ p∨(q∨r)"
oops

lemma ejercicio_33:
"p∧(q∨r) ⟹ (p∧q)∨(p∧r)"
oops

lemma ejercicio_34:
"(p∧q)∨(p∧r) ⟹ p∧(q∨r)"
oops

lemma ejercicio_35:
"p∨(q∧r) ⟹ (p∨q)∧(p∨r)"
oops

lemma ejercicio_36:
"(p∨q)∧(p∨r) ⟹ p∨(q∧r)"
oops

lemma ejercicio_37:
"(p⟶r)∧(q⟶r) ⟹ p∨q⟶r"
oops

lemma ejercicio_38:
"p∨q⟶r ⟹ (p⟶r)∧(q⟶r)"
oops

lemma ejercicio_39:
"p ⟹ ¬¬p"
oops

lemma ejercicio_40:
"¬p ⟹ p⟶q"
oops

lemma ejercicio_41:
"p⟶q ⟹ ¬q⟶¬p"
oops

lemma ejercicio_42:
"⟦p∨q; ¬q⟧ ⟹ p"
oops

lemma ejercicio_43:
"⟦p∨q; ¬p⟧ ⟹ q"
oops

lemma ejercicio_44:
"p∨q ⟹ ¬(¬p∧¬q)"
oops

lemma ejercicio_45:
"p∧q ⟹ ¬(¬p∨¬q)"
oops

lemma ejercicio_46:
"¬(p∨q) ⟹ ¬p∧¬q"
oops

lemma ejercicio_47:
"¬p∧¬q ⟹ ¬(p∨q)"
oops

lemma ejercicio_48:
"¬p∨¬q ⟹ ¬(p∧q)"
oops

lemma ejercicio_49:
"¬(p∧¬p)"
oops

lemma ejercicio_50:
"p∧¬p ⟹ q"
oops

lemma ejercicio_51:
"¬¬p ⟹ p"
oops

lemma ejercicio_52:
"p∨¬p"
oops

lemma ejercicio_53:
"((p⟶q)⟶p)⟶p"
oops

lemma ejercicio_54:
"¬q⟶¬p ⟹ p⟶q"
oops

lemma ejercicio_55:
"¬(¬p∧¬q) ⟹ p∨q"
oops

lemma ejercicio_56:
"¬(¬p∨¬q) ⟹ p∧q"
oops

lemma ejercicio_57:
"¬(p∧q) ⟹ ¬p∨¬q"
oops

lemma ejercicio_58:"(p⟶q)∨(q⟶p)"
oops

end
</source>

Tema 3 ej

2011-03-29T11:46:43Z

Jalonso: Protegió «Tema 3 ej» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

Tema 3 ej

2011-03-29T11:46:34Z

Jalonso: Página creada con '<source lang="isar"> header {* Deducción natural proposicional *} theory Tema_3_ej imports Main begin text {* Los ejercicios de esta relación deben de resolverse usando s...'

Ejercicios

2011-03-29T11:26:55Z

Jalonso: /* Ejercicios de Demostración asistida por ordenador */

== Ejercicios de ''Demostración asistida por ordenador'' ==
* '''Tema 2:''' Razonamiento sobre programas ([[Rel_1|Enunciado]] y [[Relación 1|Solución colaborativa]]).
* '''Tema 3:''' Deducción natural proposicional con Isabelle ([[Tema_3_ej|Enunciado]] y [[Ejercicios del tema 3 |Solución colaborativa]]).

Tema 3: Deducción lógica proposicional con Isabelle

2011-03-29T11:24:12Z

Jalonso: Protegió «Tema 3: Deducción lógica proposicional con Isabelle» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

<source lang="isar">
header {* Deducción natural proposicional *}

theory Tema_3
imports Main
begin

text {*
En esta teoría 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://www.cs.bham.ac.uk/research/projects/lics/ y, más concretamente,
a la forma como se explica en la asignatura de "Lógica informática" y
que puede verse en
http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf

La página al lado de cada teorema indica la página de las anteriores
transparencias donde se encuentra la demostración.
*}

section {* Reglas de la conjunción *}

text {*
La regla de introducción de la conjunción es
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q
Las reglas de eliminación de la conjunción son
· conjunct1: P ∧ Q ⟹ P
· conjunct2: P ∧ Q ⟹ Q
*}

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

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

section {* 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
que, de momento, no detallamos su demostración.
*}

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

lemma -- "p. 5"
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 "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

section {* Regla de eliminación del condicional *}

text {*
La regla de eliminación del condicional es la regla del modus ponens
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q
*}

lemma -- "p. 6"
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

lemma -- "p. 6"
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 "r" using 5 4 by (rule mp)
qed

section {* Regla derivada del modus tollens *}

text {*
Para ajustarnos al tema de LI vamos a introducir la regla del modus
tollens
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F
sin, de momento, detallar su demostración.
*}

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

lemma -- "p. 7"
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

lemma -- "p. 7"
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

lemma
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

section {* Regla de introducción del condicional *}

text {*
La regla de introducción del condicional es
· impI: (P ⟹ Q) ⟹ P ⟶ Q
*}

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 3: "¬q"
have "¬p" using 1 3 by (rule mt)
} thus "¬q ⟶ ¬p" by (rule impI)
qed

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 3: "¬q"
show "¬p" using 1 3 by (rule mt)
qed

lemma -- "p. 8"
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume 3: "¬q"
show "¬p" using 1 3 by (rule mt)
qed

lemma -- "p. 9"
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

lemma -- "p. 9"
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof (rule impI)
assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
show "¬¬q" using 1 3 by (rule mt)
qed

lemma -- "p. 9"
"p ⟶ p"
proof (rule impI)
qed

lemma -- "p. 10"
"(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

lemma -- "p. 10"
"(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

lemma
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

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

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

section {* Reglas de la disyunción *}

text {*
Las reglas de la introducción de la disyunción son
· disjI1: P ⟹ P ∨ Q
· disjI2: Q ⟹ P ∨ Q
La regla de elimación de la disyunción es
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R
*}

lemma -- "p. 11"
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

lemma -- "p. 12"
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

lemma
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1
proof (rule disjE)
{ assume 2: "p ∨ q"
thus "p ∨ (q ∨ r)"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ (q ∨ r)" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "q ∨ r" using 4 by (rule disjI1)
show "p ∨ (q ∨ r)" using 5 by (rule disjI2) }
qed }
next
{ assume 6: "r"
have 7: "q ∨ r" using 6 by (rule disjI2)
show "p ∨ (q ∨ r)" using 7 by (rule disjI2) }
qed

lemma
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: "p" using 1 ..
have "q ∨ r" using 1 ..
thus "(p ∧ q) ∨ (p ∧ r)"
proof (rule disjE)
{ assume 3: "q"
have "p ∧ q" using 2 3 by (rule conjI)
thus "(p ∧ q) ∨ (p ∧ r)" by (rule disjI1) }
next
{ assume 4: "r"
have "p ∧ r" using 2 4 by (rule conjI)
thus "(p ∧ q) ∨ (p ∧ r)" by (rule disjI2) }
qed
qed

section {* Regla de copia *}

lemma -- "p. 13"
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof
assume "q"
show "p" using 1 by this
qed
qed

lemma -- "p. 13"
"p ⟶ (q ⟶ p)"
proof
assume "p"
thus "q ⟶ p" by (rule impI)
qed

section {* Reglas de la negación *}

text {*
La regla de eliminación de lo falso es
· FalseE: False ⟹ P
La regla de eliminación de la negación es
· notE: ⟦¬P; P⟧ ⟹ R
La regla de introducción de la negación es
· notI: (P ⟹ False) ⟹ ¬P
*}

lemma -- "p. 15"
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof
assume 2: "p"
note 1
thus "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume "q"
thus "q" by this}
qed
qed

lemma -- "p. 16"
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

lemma
assumes 1: "p ⟶ ¬p"
shows "¬p"
proof (rule notI)
assume 2: "p"
have 3: "¬p" using 1 2 by (rule mp)
show False using 3 2 by (rule notE)
qed

lemma
assumes 1: "p ∧ ¬q ⟶ r" and
2: "¬r" and
3: "p"
shows "q"
proof -
have "¬¬q"
proof (rule notI)
assume 4: "¬q"
have 5: "p ∧ ¬q" using 3 4 by (rule conjI)
have 6: "r" using 1 5 by (rule mp)
show False using 2 6 by (rule notE)
qed
thus "q" by (rule notnotD)
qed

lemma
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof (rule notI)
assume 4: "q"
have 5: "q ⟶ r" using 1 2 by (rule mp)
have 6: "r" using 5 4 by (rule mp)
show False using 3 6 by (rule notE)
qed

section {* Reglas del bicondicional *}

text {*
La regla de introducción del bicondicional es
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q
Las reglas de eliminación del bicondicional son
· iffD1: ⟦Q = P; Q⟧ ⟹ P
· iffD2: ⟦P = Q; Q⟧ ⟹ P
*}

lemma -- "p. 17"
"(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

lemma -- "p. 18"
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

section {* Reglas derivadas *}

subsection {* Regla del modus tollens *}

lemma -- "p. 20"
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

subsection {* Regla de la introducción de la doble negación *}

lemma -- "p. 21"
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

subsection {* Regla de reducción al absurdo *}

lemma -- "p. 22"
assumes 1: "¬F ⟶ False"
shows "F"
proof -
have 2: "¬¬F"
proof (rule notI)
assume 3: "¬F"
show False using 1 3 by (rule mp)
qed
show "F" using 2 by (rule notnotD)
qed

text {*
La regla de reducción al absurdo en Isabelle se correponde con la
regla de contradicción
· ccontr: (¬P ⟹ False) ⟹ P
*}

subsection {* Ley del tercio excluso *}

text {*
La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
Puede demostrarse como se muestra a continuación.
*}

lemma -- "p. 23"
"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

lemma -- "p. 24"
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

end
</source>

Tema 3: Deducción lógica proposicional con Isabelle

2011-03-29T11:24:01Z

Jalonso: Página creada con '<source lang="isar"> header {* Deducción natural proposicional *} theory Tema_3 imports Main begin text {* En esta teoría se presentan los ejemplos del tema de deducción...'

Temas

2011-03-29T11:19:27Z

Jalonso: /* Temas de Demostración asistida por ordenador */

== Temas de ''Demostración asistida por ordenador'' ==
* [[Tema 1: Isabelle como un lenguaje funcional]].
* [[Tema 2: Razonamiento sobre programas]].
* [[Tema 3: Deducción lógica proposicional con Isabelle]].

Relación 1

2011-03-22T18:34:44Z

Jalonso:

<source lang="isar">
header {* Razonamiento en Isabelle sobre programas *}

theory Relacion_1
imports Main Efficient_Nat
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
------------------------------------------------------------------ *}

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

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

lemma "sumaImpares 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
------------------------------------------------------------------ *}

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

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

lemma "sumaPotenciasDeDosMasUno n = 2^(Suc n)"
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 2 = [2,2,2]
------------------------------------------------------------------ *}

fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []"
| "copia (Suc n) x = x#(copia n 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 ∧
------------------------------------------------------------------ *}

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

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

text {* ---------------------------------------------------------------
Ejercicio 9. Se considera la siguiente definición iterativa de la
función factorial
factI :: Integer -> Integer
factI n = factI' n 1

factI' :: Integer -> Integer -> Integer
factI' 0 x = x -- factI'.1
factI' (n+1) x = factI' n (n+1)*x -- factI'.2
Comprobar con QuickCheck que factI y factR son equivalentes sobre los
números naturales.
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 10. Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
y, como corolario, que
factI n = factR n
------------------------------------------------------------------- *}

text {* ---------------------------------------------------------------
Ejercicio 12. 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 [2,5] 3 = [2,5,3]
------------------------------------------------------------------ *}

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

end
</source>

Relación 1

2011-03-22T18:33:50Z

Jalonso:

DAO2011 (Demostración asistida por ordenador)

2011-03-08T16:25:22Z

Jalonso: /* Material para el curso */

Ejercicios

2011-03-01T22:07:21Z

Jalonso: /* Ejercicios */

== Ejercicios de ''Demostración asistida por ordenador'' ==
* '''Relación 1:''' Razonamiento sobre programas ([[Rel_1|Enunciado]] y [[Relación 1|Solución colaborativa]]).

Temas

2011-03-01T22:06:44Z

Jalonso:

== Temas de ''Demostración asistida por ordenador'' ==
* [[Tema 1: Isabelle como un lenguaje funcional]].
* [[Tema 2: Razonamiento sobre programas]].

Ejercicios

2011-03-01T22:05:58Z

Jalonso: /* Ejercicios */

== Ejercicios ==
* '''Relación 1:''' Razonamiento sobre programas ([[Rel_1|Enunciado]] y [[Relación 1|Solución colaborativa]]).

Temas

2011-03-01T22:05:36Z

Jalonso: Protegió «Temas» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

* [[Tema 1: Isabelle como un lenguaje funcional]].
* [[Tema 2: Razonamiento sobre programas]].

DAO2011 (Demostración asistida por ordenador)

2011-03-01T22:05:18Z

Jalonso: Protegió «DAO2011 (Demostración asistida por ordenador)» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

== Demostración asistida por ordenador ==
Este curso es una introducción a la demostración asistida por ordenador usando el sistema [http://www.cl.cam.ac.uk/research/hvg/Isabelle Isabelle/HOL/Isar]). Los objetivos del curso son:
* desarrollar la capacidad de razonamiento lógico,
* conocer formalismos de representación del conocimiento matemático,
* saber usar sistemas de razonamiento y
* desarrollar teorías matemáticas en sistemas de demostración automática.

Administrativamente, es un [http://www.cfp.us.es/web/ficha_avanzada.asp?id_titulo=846&tipo=FE&basica=1&curso=2010 curso de formación especializada] del [http://www.cfp.us.es/ Centro de Formación Permanente de la Universidad de Sevilla].

== Material para el curso ==
* [[Temas]]: Teorías de los temas.
* [[Ejercicios]]: Relaciones de ejercicios.
* [http://www.cs.us.es/~jalonso/cursos/dao/doc.html Documentación]:Enlaces con documentación.
* [http://www.cs.us.es/~jalonso/cursos/dao/sistemas.html Sistemas]: Sistemas utilizados.
* [http://www.glc.us.es/~jalonso/vestigium/tag/dao2011/ Diario]: Descripción diaria de las clases.