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

Documentación

2022-02-08T17:23:10Z

Jalonso:

En esta página se recogen en enlaces que sirven de documentación al curso de demostración asistida por ordenador (DAO). Los enlaces están actualizados en el [https://www.glc.us.es/~jalonso/RA2019/index.php/Documentaci%C3%B3n curso 2019-20].

== Visiones generales de la DAO ==

# J.A. Alonso. [http://goo.gl/NWk7b Razonamiento formalizado: Del sueño a la realidad de las pruebas]. ''Vestigium'', 26 de diciembre de 2012.
# J. Avigad. [http://www.andrew.cmu.edu/user/avigad/Talks/icerm.pdf Interactive theorem proving, automated reasoning, and mathematical computation]. ICERM, 14 de diciembre de 2012.
# M. Davis. [http://www.cs.nyu.edu/cs/faculty/davism/early.ps The early history of automated deduction].
# J.P. Delahaye [http://interstices.info/jcms/int_63417/du-reve-a-la-realite-des-preuves Du rêve à la réalité des preuves]. ''Interstices'', 8 de julio de 2012.
# J. Germoni [http://images.math.cnrs.fr/Coq-et-caracteres.html Coq et caractères: Preuve formelle du théorème de Feit et Thompson]. ''Images des Mathématiques'', CNRS, 23 de noviembre de 2012.
# H. Geuvers [http://www.ias.ac.in/sadhana/Pdf2009Feb/3.pdf Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [https://backspaces.net/temp/Spring2010Seminar/18%20unconventional%20essays%20on%20the%20nature%20of%20mathematics.pdf#page=147 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://tptp.org/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [https://www.cs.ru.nl/F.Wiedijk/pubs/qed2.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [https://web.cs.wpi.edu/~dd/resources_isabelle/isabelle_primer_mathematicians.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [https://isabelle.in.tum.de/website-Isabelle2009/dist/Isabelle/doc/tutorial.pdf A proof assistant for higher-order logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/library/HOL/HOL/document.pdf Isabelle/HOL — Higher-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/i1m-12/temas/2012-13-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# J.A. Alonso y M.J. Hidalgo [http://www.cs.us.es/~jalonso/publicaciones/Piensa_en_Haskell.pdf Piensa en Haskell (Ejercicios de programación funcional con Haskell)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# G. Hutton [http://goo.gl/pKqG Programming in Haskell]. Cambridge University Press, 2007.
# M. Lipovača [http://aprendehaskell.es ¡Aprende Haskell por el bien de todos!].

=== Lógica computacional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/li-12/temas/temas-LI-2012-13.pdf Temas de "Lógica informática" (2012-13)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# R. Bornat [http://bit.ly/oithic Proof and disproof in formal logic: an introduction for programmers]. Oxford University Press, 2005.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [https://www.doc.ic.ac.uk/~susan/firstyearbook.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [https://books.google.es/books?id=YCC6lwEACAAJ&dq=The+Haskell+Road+to+Logic,+Maths+and+Programming&hl=es&sa=X&redir_esc=y The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://goo.gl/TMqOo Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# A.D. Brucker, D. Basin, J.G. Smaus y B. Wolff. [http://archiv.infsec.ethz.ch/education/permanent/csmr.html Computer-supported Modeling and Reasoning]. (ETH Zurich, 2011).
# Mads Dam. [http://www.csc.kth.se/utbildning/kth/kurser/DD2453/aform07/ Advanced formal methods]. (KTH Royal Institute of Technology, 2007).
# Jacques Fleuriot y Paul Jackson. [http://www.inf.ed.ac.uk/teaching/courses/ar/slides/ Automated reasoning]. (Univ. de Edimburgo, 2012-13).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [https://www21.in.tum.de/teaching/semantics/WS1920/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li-12/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Yves Bertot, Pierre Casteran, Benjamin Gregoire, Pierre Letouzey y Assia Mahboubi [http://www.di.ens.fr/~zappa/teaching/coq/ecole11 Modelling and verifying algorithms in Coq: an introduction]. (INRIA Paris-Rocquencourt, 14-18 noviembre 2011).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Ian Hodkinson [http://www.doc.ic.ac.uk/~imh/teaching/140_logic/logic.html Logic] (Imperial College, Londres, 2010-11).
# Peter Lucas [http://www.cs.ru.nl/~peterl/teaching/KeR/ Knowledge Representation and Reasoning] (Radboud University # egen, 2011-12).
# Larry Paulson [http://www.cl.cam.ac.uk/Teaching/current/LogicProof/ Logic and Proof] (Univ. de Cambridge, 2011-12).
# Riccardo Pucella [http://www.ccs.neu.edu/home/riccardo/courses/csu290-sp09/index.html Logic and Computation] (Northeastern University, 2009). Curso con ACL2.

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].

Documentación

2022-02-08T12:54:08Z

Jalonso:

En esta página se recogen en enlaces que sirven de documentación al curso de demostración asistida por ordenador (DAO).

== Visiones generales de la DAO ==

# J.A. Alonso. [http://goo.gl/NWk7b Razonamiento formalizado: Del sueño a la realidad de las pruebas]. ''Vestigium'', 26 de diciembre de 2012.
# J. Avigad. [http://www.andrew.cmu.edu/user/avigad/Talks/icerm.pdf Interactive theorem proving, automated reasoning, and mathematical computation]. ICERM, 14 de diciembre de 2012.
# M. Davis. [http://www.cs.nyu.edu/cs/faculty/davism/early.ps The early history of automated deduction].
# J.P. Delahaye [http://interstices.info/jcms/int_63417/du-reve-a-la-realite-des-preuves Du rêve à la réalité des preuves]. ''Interstices'', 8 de julio de 2012.
# J. Germoni [http://images.math.cnrs.fr/Coq-et-caracteres.html Coq et caractères: Preuve formelle du théorème de Feit et Thompson]. ''Images des Mathématiques'', CNRS, 23 de noviembre de 2012.
# H. Geuvers [http://www.ias.ac.in/sadhana/Pdf2009Feb/3.pdf Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [https://backspaces.net/temp/Spring2010Seminar/18%20unconventional%20essays%20on%20the%20nature%20of%20mathematics.pdf#page=147 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://tptp.org/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [https://www.cs.ru.nl/F.Wiedijk/pubs/qed2.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [https://web.cs.wpi.edu/~dd/resources_isabelle/isabelle_primer_mathematicians.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [https://isabelle.in.tum.de/website-Isabelle2009/dist/Isabelle/doc/tutorial.pdf A proof assistant for higher-order logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/library/HOL/HOL/document.pdf Isabelle/HOL — Higher-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/i1m-12/temas/2012-13-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# J.A. Alonso y M.J. Hidalgo [http://www.cs.us.es/~jalonso/publicaciones/Piensa_en_Haskell.pdf Piensa en Haskell (Ejercicios de programación funcional con Haskell)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# G. Hutton [http://goo.gl/pKqG Programming in Haskell]. Cambridge University Press, 2007.
# M. Lipovača [http://aprendehaskell.es ¡Aprende Haskell por el bien de todos!].

=== Lógica computacional ===
# J.A. Alonso [http://www.cs.us.es/~jalonso/cursos/li-12/temas/temas-LI-2012-13.pdf Temas de "Lógica informática" (2012-13)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2012.
# R. Bornat [http://bit.ly/oithic Proof and disproof in formal logic: an introduction for programmers]. Oxford University Press, 2005.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [https://www.doc.ic.ac.uk/~susan/firstyearbook.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [https://books.google.es/books?id=YCC6lwEACAAJ&dq=The+Haskell+Road+to+Logic,+Maths+and+Programming&hl=es&sa=X&redir_esc=y The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://goo.gl/TMqOo Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# A.D. Brucker, D. Basin, J.G. Smaus y B. Wolff. [http://archiv.infsec.ethz.ch/education/permanent/csmr.html Computer-supported Modeling and Reasoning]. (ETH Zurich, 2011).
# Mads Dam. [http://www.csc.kth.se/utbildning/kth/kurser/DD2453/aform07/ Advanced formal methods]. (KTH Royal Institute of Technology, 2007).
# Jacques Fleuriot y Paul Jackson. [http://www.inf.ed.ac.uk/teaching/courses/ar/slides/ Automated reasoning]. (Univ. de Edimburgo, 2012-13).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [https://www21.in.tum.de/teaching/semantics/WS1920/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li-12/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Yves Bertot, Pierre Casteran, Benjamin Gregoire, Pierre Letouzey y Assia Mahboubi [http://www.di.ens.fr/~zappa/teaching/coq/ecole11 Modelling and verifying algorithms in Coq: an introduction]. (INRIA Paris-Rocquencourt, 14-18 noviembre 2011).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Ian Hodkinson [http://www.doc.ic.ac.uk/~imh/teaching/140_logic/logic.html Logic] (Imperial College, Londres, 2010-11).
# Peter Lucas [http://www.cs.ru.nl/~peterl/teaching/KeR/ Knowledge Representation and Reasoning] (Radboud University # egen, 2011-12).
# Larry Paulson [http://www.cl.cam.ac.uk/Teaching/current/LogicProof/ Logic and Proof] (Univ. de Cambridge, 2011-12).
# Riccardo Pucella [http://www.ccs.neu.edu/home/riccardo/courses/csu290-sp09/index.html Logic and Computation] (Northeastern University, 2009). Curso con ACL2.

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].

Temas

2017-02-08T18:41:19Z

Jalonso:

== Temas de ''Razonamiento automático (2016-17)'' ==

* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5: Razonamiento sobre árboles y bosques]].
* Tema 6: Verificación de algoritmos de ordenación:
** [[Tema 6a: Verificación de la ordenación por inserción]].
** [[Tema 6b: Verificación de la ordenación por mezcla]].
* [[Tema 7: Caso de estudio: Compilación de expresiones]].
* Tema 8: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 8a: Deducción natural proposicional].
** [[Tema 8b: Deducción natural proposicional con Isabelle/HOL]].
* Tema 9: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 9a: Deducción natural en lógica de primer orden].
** [[Tema 9b: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 10: Conjuntos, funciones y relaciones]].
* [http://www.cs.us.es/~jalonso/cursos/dao-12/temas/tema-1.pdf Tema 11: Panorama de la demostración asistida por ordenador].

Tema 10: Conjuntos, funciones y relaciones

2017-02-02T14:39:59Z

Jalonso:

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

theory T10_Conjuntos_funciones_y_relaciones
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

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

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

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

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

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

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

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

text {*
Ejemplo: A ∪ B ⊆ C syss A ⊆ C ∧ B ⊆ C.
*}

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

text {*
Ejemplo: A ⊆ -B syss B ⊆ -A.
*}

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

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

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

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

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

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

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

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

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

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

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

subsection {* Notación de conjuntos finitos *}

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

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

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

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

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

text {*
Ejemplo: {a,b} ∪ {c,d} = {a,b,c,d}
*}

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

text {*
Ejemplo de conjetura falsa y su refutación.
*}

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

text {*
Ejemplo con la conjetura corregida.
*}

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

text {*
Sumas de conjuntos finitos:
· ∑A es la suma de los elementos del conjunto finito A. Por ejemplo,
value "∑{1,2,3}::int" -- "= 6"
· (setsum f A) es la suma de la aplicación de f a los elementos del
conjunto finito A, Por ejemplo,
value "setsum (λx. x*x) {1,2,3}::int" -- "= 14"
*}

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

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

value "sumaConj {2,5,3} = 10"

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

value "sumaCuadradosConj {2,5,3} = 38"

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

declare sumaConj_def[simp]
declare sumaCuadradosConj_def[simp]

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

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

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

text {*
Ejemplo de inducción sobre conjuntos finitos: Sea S un conjunto finito
de números naturales. Entonces todos los elementos de S son menores o
iguales que la suma de los elementos de S.
*}

-- "La demostración automática es"
lemma "finite S ⟹ ∀x∈S. x ≤ sumaConj S"
by (induct rule: finite_induct) auto

-- "La demostración estructurada es"
lemma sumaConj_acota:
"finite S ⟹ ∀x∈S. x ≤ sumaConj S"
proof (induct rule: finite_induct)
show "∀x ∈ {}. x ≤ sumaConj {}" by simp
next
fix x and F
assume fF: "finite F"
and xF: "x ∉ F"
and HI: "∀ x∈F. x ≤ sumaConj F"
show "∀y ∈ insert x F. y ≤ sumaConj (insert x F)"
proof
fix y
assume "y ∈ insert x F"
show "y ≤ sumaConj (insert x F)"
proof (cases "y = x")
assume "y = x"
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
*}

text {*
Ejemplo de comprensión: {x. P x ∨ x ∈ A} = {x. P x} ∪ A
*}

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

text {*
Ejemplo de comprensión: {x. P x ⟶ Q x} = -{x. P x} ∪ {x. Q x}
*}

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

text {*
Ejemplo con la sintaxis general de comprensión.
{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}
*}

lemma
"{p*q | p q. p ∈ prime ∧ q ∈ prime} =
{z. ∃p q. z = p*q ∧ p ∈ prime ∧ q ∈ prime}"
by 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 {*
Ejemplo de definición por comprensión: El conjunto de los pares es el
de los números n para los que existe un m tal que n = 2*m.
*}

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

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

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

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

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

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

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

-- "La demostración estructurada es"
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" ..
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" ..
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

-- "La demostración automática es"
lemma "x ∉ (Pares ∩ Impares)"
by (auto simp add: Pares_def Impares_def, arith)

subsection {* Cuantificadores acotados *}

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

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

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

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

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

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

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

subsection {* Conjuntos finitos y cardinalidad *}

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

text {*
Ejemplos de cardinales de conjuntos finitos.
*}

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

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

section {* Funciones *}

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

subsection {* Nociones básicas de funciones *}

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

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

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

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

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

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

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

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

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

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

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

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

text {*
Ejemplo de lema de demostración de propiedades de funciones: Una
función inyectiva puede cancelarse en el lado izquierdo de la
composición de funciones.
*}

-- "La demostración detallada es"
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
then show "g(x) = h(x)" using `inj f` by (simp add:inj_on_def)
qed
next
assume "g = h"
show "f ∘ g = f ∘ h"
proof
fix x
have "(f ∘ g) x = f(g(x))" by simp
also have "… = f(h(x))" using `g = h` by simp
also have "… = (f ∘ h) x" by simp
finally show "(f ∘ g) x = (f ∘ h) x" by simp
qed
qed

-- "La demostración estructurada es"
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: inj_on_def fun_eq_iff)
next
assume "g = h"
thus "f ∘ g = f ∘ h" by auto
qed

-- "La demostración automática es"
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
using assms
by (auto simp add: inj_on_def fun_eq_iff)

subsubsection {* Función imagen *}

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

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

text {*
Ejemplo de demostración de propiedades de la imagen:
f`A ∪ g`A = (⋃x∈A. {f x, g x})
*}

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

text {*
Ejemplo de demostración de propiedades de la imagen:
f`{(x,y). P x y} = {f(x,y) | x y. P x y}
*}

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

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

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

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

section {* Relaciones *}

subsection {* Relaciones básicas *}

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

Las relaciones son conjuntos de pares.

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

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

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

Imagen inversa de una relación:
· converse_iff: ((a,b) ∈ r^-1) = ((b,a) ∈ r)

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

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

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

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

end
</source>

Sistemas

2017-01-26T14:12:08Z

Jalonso: /* Sistemas utilizados en Razonamiento automático (2016-17) */

== Sistemas utilizados en ''Razonamiento automático (2016-17)'' ==

En esta página se irá escribiendo enlaces a los sistemas utilizados en el curso
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/index.html Isabelle/HOL].
# [http://www.glc.us.es/apli2 APLI2 (APLIcación de Ayuda Para Lógica Informática)].

Relación 10

2017-01-26T07:29:51Z

Jalonso: Página creada con '<source lang="isar"> chapter {* R10: Formalización y argumentación con Isabelle/HOL *} theory R10_Formalizacion_y_argmentacion imports Main begin text {* ----------------...'

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

theory R10_Formalizacion_y_argmentacion
imports Main
begin

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

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

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

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

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

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y decidir la corrección, del siguiente
argumento
Los aficionados al fútbol aplauden a cualquier futbolista
extranjero. Juanito no aplaude a futbolistas extranjeros. Por
tanto, si hay algún futbolista extranjero nacionalizado español,
Juanito no es aficionado al fútbol.
Usar Af(x) para x es aficicionado al fútbol
Ap(x,y) para x aplaude a y
E(x) para x es un futbolista extranjero
N(x) para x es un futbolista nacionalizado español
j para Juanito
------------------------------------------------------------------ *}

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

end
</source>

R10

2017-01-26T07:29:30Z

Jalonso: Protegió «R10» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

R10

2017-01-26T07:29:12Z

Ejercicios

2017-01-26T07:28:12Z

Jalonso:

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]] y [[Relación 1 | Solución colaborativa]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]] y [[Relación 2 | Solución colaborativa]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]] y [[Relación 3 | Solución colaborativa]]).
* '''Relación 4''': Cuantificadores sobre listas. ([[R4 |Enunciado]] y [[Relación 4 | Solución colaborativa]]).
* '''Relación 5''': Eliminación de duplicados. ([[R5 |Enunciado]] y [[Relación 5 | Solución colaborativa]]).
* '''Relación 6''': Recorridos de árboles. ([[R6 |Enunciado]] y [[Relación 6 | Solución colaborativa]]).
* '''Relación 7''': Árboles binarios completos. ([[R7 |Enunciado]] y [[Relación 7 | Solución colaborativa]]).
* '''Relación 8''': Deducción natural proposicional en Isabelle/HOL. ([[R8 |Enunciado]] y [[Relación 8 | Solución colaborativa]]).
* '''Relación 9''': Deducción natural LPO en Isabelle/HOL. ([[R9 |Enunciado]] y [[Relación 9 | Solución colaborativa]]).
* '''Relación 10''': Formalización y argumentación en Isabelle/HOL. ([[R10 |Enunciado]] y [[Relación 10 | Solución colaborativa]]).



=== Soluciones en GitHub ===

Los siguientes repositorios de GitHub también contienen soluciones de alumnos del curso: [https://github.com/MULCIA/RAIsabelleHOL serrodcal].

Tema 10: Conjuntos, funciones y relaciones

2017-01-26T07:05:44Z

Jalonso: Protegió «Tema 10: Conjuntos, funciones y relaciones» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

Tema 10: Conjuntos, funciones y relaciones

2017-01-26T07:05:27Z

Jalonso: Página creada con '<source lang="isar"> chapter {* Tema 10: Conjuntos, funciones y relaciones *} theory T10_Conjuntos_funciones_y_relaciones imports Main begin section {* Conjuntos *} subsecti...'

Temas

2017-01-26T06:10:13Z

Jalonso:

== Temas de ''Razonamiento automático (2016-17)'' ==

* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5: Razonamiento sobre árboles y bosques]].
* Tema 6: Verificación de algoritmos de ordenación:
** [[Tema 6a: Verificación de la ordenación por inserción]].
** [[Tema 6b: Verificación de la ordenación por mezcla]].
* [[Tema 7: Caso de estudio: Compilación de expresiones]].
* Tema 8: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 8a: Deducción natural proposicional].
** [[Tema 8b: Deducción natural proposicional con Isabelle/HOL]].
* Tema 9: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 9a: Deducción natural en lógica de primer orden].
** [[Tema 9b: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 10: Conjuntos, funciones y relaciones]].

Relación 9

2017-01-26T05:52:25Z

Jalonso: Desprotegió «Relación 9»

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

theory R9_Deduccion_natural_LPO
imports Main
begin

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

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

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

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

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

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

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

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

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

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

(* ivamenjim bowma *)

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

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

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

(* Comentario: Usa simp *)

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

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

(* ivamenjim *)
(* Semejante al anterior, pero indicando que se pruebe por la regla
correspondiente *)
lemma ejercicio_2_1:
assumes 1: "∀x y z. R x y ∧ R y z ⟶ R x z"
assumes 2: "∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix x
show "∀y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix y
{assume 3: "R x y"
{assume 4: "R y x"
have 5: "R x y ∧ R y x" using 3 4 ..
have 6: "∀ y z. R x y ∧ R y z ⟶ R x z" using 1 ..
then have 7: "∀ z. R x y ∧ R y z ⟶ R x z" ..
then have 8: "R x y ∧ R y x ⟶ R x x" ..
then have 9: "R x x" using 5 ..
have 10: "¬(R x x)" using 2 ..
then have 11: "False" using 9 ..}
then have 12: "¬ (R y x)" ..}
thus "R x y ⟶ ¬(R y x)" ..
qed
qed

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_3_3:
shows "(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
quickcheck
oops

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

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

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

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

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

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

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

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

end
</source>

Relación 9

2017-01-25T19:21:55Z

Jalonso:

Relación 9

2017-01-25T19:02:47Z

Jalonso: Protegió «Relación 9» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

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

theory R9_Deduccion_natural_LPO
imports Main
begin

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

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

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

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

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

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

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

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

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

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

(* ivamenjim bowma *)

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

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

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

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

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

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

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

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_3_3:
shows "(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
quickcheck
oops

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

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

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

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

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

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

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

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

end
</source>

Relación 9

2017-01-19T12:07:56Z

Jalonso: Página creada con '<source lang="isar"> chapter {* R9: Deducción natural LPO en Isabelle/HOL *} theory R9_Deduccion_natural_LPO imports Main begin text {* Demostrar o refutar los siguientes ...'

R9

2017-01-19T12:07:37Z

Jalonso: Protegió «R9» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

R9

2017-01-19T12:07:19Z

Ejercicios

2017-01-19T12:06:23Z

Jalonso:

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]] y [[Relación 1 | Solución colaborativa]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]] y [[Relación 2 | Solución colaborativa]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]] y [[Relación 3 | Solución colaborativa]]).
* '''Relación 4''': Cuantificadores sobre listas. ([[R4 |Enunciado]] y [[Relación 4 | Solución colaborativa]]).
* '''Relación 5''': Eliminación de duplicados. ([[R5 |Enunciado]] y [[Relación 5 | Solución colaborativa]]).
* '''Relación 6''': Recorridos de árboles. ([[R6 |Enunciado]] y [[Relación 6 | Solución colaborativa]]).
* '''Relación 7''': Árboles binarios completos. ([[R7 |Enunciado]] y [[Relación 7 | Solución colaborativa]]).
* '''Relación 8''': Deducción natural proposicional en Isabelle/HOL. ([[R8 |Enunciado]] y [[Relación 8 | Solución colaborativa]]).
* '''Relación 9''': Deducción natural LPO en Isabelle/HOL. ([[R9 |Enunciado]] y [[Relación 9 | Solución colaborativa]]).



=== Soluciones en GitHub ===

Los siguientes repositorios de GitHub también contienen soluciones de alumnos del curso: [https://github.com/MULCIA/RAIsabelleHOL serrodcal].

Relación 8

2017-01-19T11:14:52Z

Jalonso:

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

theory R8_Deduccion_natural_proposicional
imports Main
begin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_1_7:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof-
{assume "p"
assume "¬q"
have "¬p" using assms(1) `¬q` by (rule mp)}
thus "p ⟶ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

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

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

(* Comentario: No se corresponde con el enunciado. *)

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

(* Comentario: Usa auto. *)

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

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

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

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

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_2_7:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof-
{assume "(¬p ∧ ¬q)"
have "p" using assms `(¬p ∧ ¬q)` by (rule notE)
then have "p ∨ q" by (rule disjI1)}
then show "p ∨ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_2_8:
assumes 1: " ¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (cases)
assume "p"
then show "p ∨ q" using disjI1 by simp
next
assume "¬p"
then have "q" using 1 conjunct2 by simp
then show "p ∨ q" using disjI2 by simp
qed

(* Comentario: Uso de simp. *)

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

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

(* Comentario: Uso de la negación de la hipótesis. *)

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

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

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

(* Comentario: Uso de auxiliar con auto. *)

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

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

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

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

(* pabrodmac *)
lemma ejercicio_3_6:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬p" by (rule conjunct1)
show "p" using `¬¬p` by (rule notnotD)
next
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
hence "¬¬q" by (rule conjunct2)
show "q" using `¬¬q` by (rule notnotD)
qed

(* pabrodmac *)
lemma ejercicio_3_7:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof
have "¬¬p ∧ ¬¬q" using assms by (rule Meson.not_disjD)
have "¬¬p" using `¬¬p ∧ ¬¬q` by (rule conjunct1)
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
show "p" using `¬¬p` by (rule notnotD)
show "q" using `¬¬q` by (rule notnotD)
qed

(* dancorgar *)
lemma ejercicio_3_8:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
{assume "(¬p ∨ ¬q)"
have "p" using assms `(¬p ∨ ¬q)` by (rule notE)
have "q" using assms `(¬p ∨ ¬q)` by (rule notE)
have "p ∧ q" using `p` `q` by (rule conjI)}
then show "p ∧ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_3_9:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule ccontr)
assume "¬(p ∧ q)"
then show False using 1 by simp
qed

(* Comentario: Uso de simp. *)

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

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

(* Comentario: Uso de la negación de la hipótesis.*)

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

(* Comentario: Uso de auto. *)

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

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

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

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

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

(* pabrodmac*)
lemma ejercicio_4_7:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof -
show "¬p ∨ ¬q" using assms by (rule Meson.not_conjD)
qed

(* dancorgar *)
lemma ejercicio_4_8:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof-
{assume "(p ∧ q)"
have "¬p" using assms `(p ∧ q)` by (rule notE)
then have "¬p ∨ ¬q" by (rule disjI1)}
then show "¬p ∨ ¬q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_4:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬ p ∨ ¬ q)"
then show False using 1 by simp
qed

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

(* marcarmor13 jeamacpov serrodcal juancabsou *)
--"usando un supuesto q"
lemma ejercicio_5_1:
assumes 1: "q"
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof-
have 2: "p ⟶ q" using 1 by (rule impI)
show "(p ⟶ q) ∨ (q ⟶ p)" using 2 by (rule disjI1)
qed

(* Comentario: Hipótesis extra.*)

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

(* Comentario: Uso de auto. *)

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

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

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

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

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

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

(* josgarsan *)
lemma ejercicio_5_7:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof (cases)
assume "p"
then show "(p ⟶ q) ∨ (q ⟶ p)" by simp
next
assume "¬p"
then show "(p ⟶ q) ∨ (q ⟶ p)" by simp
qed

(* Comentario: Uso de simp. *)

(* dancorgar *)
lemma ejercicio_5_8:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof (cases)
assume "p"
have "(q ⟶ p)" using `p` by (rule impI)
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)
next
assume "¬p"
have "(p ⟶ q)" using `¬p` by simp
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)
qed

end
</source>

Relación 8

2017-01-19T10:27:27Z

Jalonso: Protegió «Relación 8» ([edit=sysop] (caduca el 10:27 20 ene 2017 (UTC)) [move=sysop] (caduca el 10:27 20 ene 2017 (UTC)))

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

theory R8_Deduccion_natural_proposicional
imports Main
begin

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

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

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

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

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

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

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

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

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_1_7:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof-
{assume "p"
assume "¬q"
have "¬p" using assms(1) `¬q` by (rule mp)}
thus "p ⟶ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

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

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

(* pablucoto jeamacpov *)

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

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

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

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

(* migtermor *)

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

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

(* paupeddeg pabrodmac *)

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

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

(*pabrodmac*)

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

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

(* dancorgar *)
lemma ejercicio_2_7:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof-
{assume "(¬p ∧ ¬q)"
have "p" using assms `(¬p ∧ ¬q)` by (rule notE)
then have "p ∨ q" by (rule disjI1)}
then show "p ∨ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_2_8:
assumes 1: " ¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (cases)
assume "p"
then show "p ∨ q" using disjI1 by simp
next
assume "¬p"
then have "q" using 1 conjunct2 by simp
then show "p ∨ q" using disjI2 by simp
qed

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

(* pablucoto jeamacpov *)

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

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

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

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

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

(* paupeddeg pabrodmac *)

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

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

(* pabrodmac *)

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

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

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

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

(* dancorgar *)
lemma ejercicio_3_8:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof-
{assume "(¬p ∨ ¬q)"
have "p" using assms `(¬p ∨ ¬q)` by (rule notE)
have "q" using assms `(¬p ∨ ¬q)` by (rule notE)
have "p ∧ q" using `p` `q` by (rule conjI)}
then show "p ∧ q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_3_9:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule ccontr)
assume "¬(p ∧ q)"
then show False using 1 by simp
qed

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

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

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

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

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

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

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

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

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

(* dancorgar *)
lemma ejercicio_4_8:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof-
{assume "(p ∧ q)"
have "¬p" using assms `(p ∧ q)` by (rule notE)
then have "¬p ∨ ¬q" by (rule disjI1)}
then show "¬p ∨ ¬q"
apply simp
apply (rule ccontr)
apply simp
done
qed

(* josgarsan *)
lemma ejercicio_4:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬ p ∨ ¬ q)"
then show False using 1 by simp
qed

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

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

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

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

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

(* migtermor *)

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

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

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

(*pabrodmac*)

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

(* josgarsan *)
lemma ejercicio_5_7:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof (cases)
assume "p"
then show "(p ⟶ q) ∨ (q ⟶ p)" by simp
next
assume "¬p"
then show "(p ⟶ q) ∨ (q ⟶ p)" by simp
qed

(* dancorgar *)
lemma ejercicio_5_8:
shows "(p ⟶ q) ∨ (q ⟶ p)"
proof (cases)
assume "p"
have "(q ⟶ p)" using `p` by (rule impI)
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI2)
next
assume "¬p"
have "(p ⟶ q)" using `¬p` by simp
then show "(p ⟶ q) ∨ (q ⟶ p)" by (rule disjI1)
qed

end
</source>

Relación 8

2017-01-12T19:33:19Z

Jalonso: Desprotegió «Relación 8»

R8

2017-01-12T11:00:22Z

Jalonso: Protegió «R8» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

Relación 8

2017-01-12T11:00:07Z

Jalonso: Protegió «Relación 8» ([edit=sysop] (caduca el 11:00 13 ene 2017 (UTC)) [move=sysop] (caduca el 11:00 13 ene 2017 (UTC)))

Relación 8

2017-01-12T10:58:59Z

Jalonso: Página creada con '<source lang="isar"> chapter {* R8: Deducción natural proposicional en Isabelle/HOL *} theory R8_Deduccion_natural_proposicional imports Main begin text {* Demostrar o ref...'

R8

2017-01-12T10:58:19Z

Ejercicios

2017-01-12T10:57:13Z

Jalonso:

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]] y [[Relación 1 | Solución colaborativa]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]] y [[Relación 2 | Solución colaborativa]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]] y [[Relación 3 | Solución colaborativa]]).
* '''Relación 4''': Cuantificadores sobre listas. ([[R4 |Enunciado]] y [[Relación 4 | Solución colaborativa]]).
* '''Relación 5''': Eliminación de duplicados. ([[R5 |Enunciado]] y [[Relación 5 | Solución colaborativa]]).
* '''Relación 6''': Recorridos de árboles. ([[R6 |Enunciado]] y [[Relación 6 | Solución colaborativa]]).
* '''Relación 7''': Árboles binarios completos. ([[R7 |Enunciado]] y [[Relación 7 | Solución colaborativa]]).
* '''Relación 8''': Deducción natural proposicional en Isabelle/HOL. ([[R8 |Enunciado]] y [[Relación 8 | Solución colaborativa]]).



=== Soluciones en GitHub ===

Los siguientes repositorios de GitHub también contienen soluciones de alumnos del curso: [https://github.com/MULCIA/RAIsabelleHOL serrodcal].

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

2017-01-12T06:53:17Z

Jalonso: Página creada con '<source lang="isar"> chapter {* Tema 9: Deducción natural en lógica de primer orden *} theory T9b_Deduccion_natural_en_logica_de_primer_orden imports Main begin text {* E...'

<source lang="isar">
chapter {* Tema 9: Deducción natural en lógica de primer orden *}

theory T9b_Deduccion_natural_en_logica_de_primer_orden
imports Main
begin

text {*
El objetivo de este tema es presentar la deducción natural en
lógica de primer orden con Isabelle/HOL. La presentación se
basa en los ejemplos de tema 8 del curso LMF que se encuentra
en http://goo.gl/uJj8d (que a su vez se basa en el libro de
Huth y Ryan "Logic in Computer Science" http://goo.gl/qsVpY ).

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

section {* Reglas del cuantificador universal *}

text {*
Las reglas del cuantificador universal son
· allE: ⟦∀x. P x; P a ⟹ R⟧ ⟹ R
· allI: (⋀x. P x) ⟹ ∀x. P x
*}

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

-- "La demostración detallada es"
lemma ejemplo_1a:
assumes 1: "P(c)" and
2: "∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
proof -
have 3: "P(c) ⟶ ¬Q(c)" using 2 by (rule allE)
show 4: "¬Q(c)" using 3 1 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_1b:
assumes "P(c)"
"∀x. (P(x) ⟶ ¬Q(x))"
shows "¬Q(c)"
proof -
have "P(c) ⟶ ¬Q(c)" using assms(2) ..
thus "¬Q(c)" using assms(1) ..
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_2a:
assumes 1: "∀x. (P x ⟶ ¬(Q x))" and
2: "∀x. P x"
shows "∀x. ¬(Q x)"
proof -
{ fix a
have 3: "P a ⟶ ¬(Q a)" using 1 by (rule allE)
have 4: "P a" using 2 by (rule allE)
have 5: "¬(Q a)" using 3 4 by (rule mp) }
thus "∀x. ¬(Q x)" by (rule allI)
qed

-- "La demostración detallada hacia atrás es"
lemma ejemplo_2b:
assumes 1: "∀x. (P x ⟶ ¬(Q x))" and
2: "∀x. P x"
shows "∀x. ¬(Q x)"
proof (rule allI)
fix a
have 3: "P a ⟶ ¬(Q a)" using 1 by (rule allE)
have 4: "P a" using 2 by (rule allE)
show 5: "¬(Q a)" using 3 4 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_2c:
assumes "∀x. (P x ⟶ ¬(Q x))"
"∀x. P x"
shows "∀x. ¬(Q x)"
proof
fix a
have "P a" using assms(2) ..
have "P a ⟶ ¬(Q a)" using assms(1) ..
thus "¬(Q a)" using `P a` ..
qed

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

section {* Reglas del cuantificador existencial *}

text {*
Las reglas del cuantificador existencial son
· exI: P a ⟹ ∃x. P x
· exE: ⟦∃x. P x; ⋀x. P x ⟹ Q⟧ ⟹ Q

En la regla exE la nueva variable se introduce mediante la declaración
"obtain ... where ... by (rule exE)"
*}

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

-- "La demostración detallada es"
lemma ejemplo_3a:
assumes "∀x. P x"
shows "∃x. P x"
proof -
fix a
have "P a" using assms by (rule allE)
thus "∃x. P x" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_3b:
assumes "∀x. P x"
shows "∃x. P x"
proof -
fix a
have "P a" using assms ..
thus "∃x. P x" ..
qed

-- "La demostración estructurada se puede simplificar"
lemma ejemplo_3c:
assumes "∀x. P x"
shows "∃x. P x"
proof (rule exI)
fix a
show "P a" using assms ..
qed

-- "La demostración estructurada se puede simplificar aún más"
lemma ejemplo_3d:
assumes "∀x. P x"
shows "∃x. P x"
proof
fix a
show "P a" using assms ..
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_4a:
assumes 1: "∀x. (P x ⟶ Q x)" and
2: "∃x. P x"
shows "∃x. Q x"
proof -
obtain a where 3: "P a" using 2 by (rule exE)
have 4: "P a ⟶ Q a" using 1 by (rule allE)
have 5: "Q a" using 4 3 by (rule mp)
thus 6: "∃x. Q x" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_4b:
assumes "∀x. (P x ⟶ Q x)"
"∃x. P x"
shows "∃x. Q x"
proof -
obtain a where "P a" using assms(2) ..
have "P a ⟶ Q a" using assms(1) ..
hence "Q a" using `P a` ..
thus "∃x. Q x" ..
qed

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

section {* Demostración de equivalencias *}

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

-- "La demostración detallada es"
lemma ejemplo_5_1a:
assumes "¬(∀x. P(x))"
shows "∃x. ¬P(x)"
proof (rule ccontr)
assume "¬(∃x. ¬P(x))"
have "∀x. P(x)"
proof (rule allI)
fix a
show "P(a)"
proof (rule ccontr)
assume "¬P(a)"
hence "∃x. ¬P(x)" by (rule exI)
with `¬(∃x. ¬P(x))` show False by (rule notE)
qed
qed
with assms show False by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_5_1b:
assumes "¬(∀x. P(x))"
shows "∃x. ¬P(x)"
proof (rule ccontr)
assume "¬(∃x. ¬P(x))"
have "∀x. P(x)"
proof
fix a
show "P(a)"
proof (rule ccontr)
assume "¬P(a)"
hence "∃x. ¬P(x)" ..
with `¬(∃x. ¬P(x))` show False ..
qed
qed
with assms show False ..
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_5_2a:
assumes "∃x. ¬P(x)"
shows "¬(∀x. P(x))"
proof (rule notI)
assume "∀x. P(x)"
obtain a where "¬P(a)" using assms by (rule exE)
have "P(a)" using `∀x. P(x)` by (rule allE)
with `¬P(a)` show False by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_5_2b:
assumes "∃x. ¬P(x)"
shows "¬(∀x. P(x))"
proof
assume "∀x. P(x)"
obtain a where "¬P(a)" using assms ..
have "P(a)" using `∀x. P(x)` ..
with `¬P(a)` show False ..
qed

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

text {*
Ejemplo 5.3 (p. 17). Demostrar
⊢ ¬∀x. P x ⟷ ∃x. ¬(P x) *}

-- "La demostración detallada es"
lemma ejemplo_5_3a:
"(¬(∀x. P(x))) ⟷ (∃x. ¬P(x))"
proof (rule iffI)
assume "¬(∀x. P(x))"
thus "∃x. ¬P(x)" by (rule ejemplo_5_1a)
next
assume "∃x. ¬P(x)"
thus "¬(∀x. P(x))" by (rule ejemplo_5_2a)
qed

-- "La demostración automática es"
lemma ejemplo_5_3b:
"(¬(∀x. P(x))) ⟷ (∃x. ¬P(x))"
by auto

text {*
Ejemplo 6.1 (p. 18). Demostrar
∀x. P(x) ∧ Q(x) ⊢ (∀x. P(x)) ∧ (∀x. Q(x)) *}

-- "La demostración detallada es"
lemma ejemplo_6_1a:
assumes "∀x. P(x) ∧ Q(x)"
shows "(∀x. P(x)) ∧ (∀x. Q(x))"
proof (rule conjI)
show "∀x. P(x)"
proof (rule allI)
fix a
have "P(a) ∧ Q(a)" using assms by (rule allE)
thus "P(a)" by (rule conjunct1)
qed
next
show "∀x. Q(x)"
proof (rule allI)
fix a
have "P(a) ∧ Q(a)" using assms by (rule allE)
thus "Q(a)" by (rule conjunct2)
qed
qed

-- "La demostración estructurada es"
lemma ejemplo_6_1b:
assumes "∀x. P(x) ∧ Q(x)"
shows "(∀x. P(x)) ∧ (∀x. Q(x))"
proof
show "∀x. P(x)"
proof
fix a
have "P(a) ∧ Q(a)" using assms ..
thus "P(a)" ..
qed
next
show "∀x. Q(x)"
proof
fix a
have "P(a) ∧ Q(a)" using assms ..
thus "Q(a)" ..
qed
qed

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

text {*
Ejemplo 6.2 (p. 19). Demostrar
(∀x. P(x)) ∧ (∀x. Q(x)) ⊢ ∀x. P(x) ∧ Q(x) *}

-- "La demostración detallada es"
lemma ejemplo_6_2a:
assumes "(∀x. P(x)) ∧ (∀x. Q(x))"
shows "∀x. P(x) ∧ Q(x)"
proof (rule allI)
fix a
have "∀x. P(x)" using assms by (rule conjunct1)
hence "P(a)" by (rule allE)
have "∀x. Q(x)" using assms by (rule conjunct2)
hence "Q(a)" by (rule allE)
with `P(a)` show "P(a) ∧ Q(a)" by (rule conjI)
qed

-- "La demostración estructurada es"
lemma ejemplo_6_2b:
assumes "(∀x. P(x)) ∧ (∀x. Q(x))"
shows "∀x. P(x) ∧ Q(x)"
proof
fix a
have "∀x. P(x)" using assms ..
hence "P(a)" by (rule allE)
have "∀x. Q(x)" using assms ..
hence "Q(a)" ..
with `P(a)` show "P(a) ∧ Q(a)" ..
qed

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

text {*
Ejemplo 6.3 (p. 20). Demostrar
⊢ ∀x. P(x) ∧ Q(x) ⟷ (∀x. P(x)) ∧ (∀x. Q(x)) *}

-- "La demostración detallada es"
lemma ejemplo_6_3a:
"(∀x. P(x) ∧ Q(x)) ⟷ ((∀x. P(x)) ∧ (∀x. Q(x)))"
proof (rule iffI)
assume "∀x. P(x) ∧ Q(x)"
thus "(∀x. P(x)) ∧ (∀x. Q(x))" by (rule ejemplo_6_1a)
next
assume "(∀x. P(x)) ∧ (∀x. Q(x))"
thus "∀x. P(x) ∧ Q(x)" by (rule ejemplo_6_2a)
qed

text {*
Ejemplo 7.1 (p. 21). Demostrar
(∃x. P(x)) ∨ (∃x. Q(x)) ⊢ ∃x. P(x) ∨ Q(x) *}

-- "La demostración detallada es"
lemma ejemplo_7_1a:
assumes "(∃x. P(x)) ∨ (∃x. Q(x))"
shows "∃x. P(x) ∨ Q(x)"
using assms
proof (rule disjE)
assume "∃x. P(x)"
then obtain a where "P(a)" by (rule exE)
hence "P(a) ∨ Q(a)" by (rule disjI1)
thus "∃x. P(x) ∨ Q(x)" by (rule exI)
next
assume "∃x. Q(x)"
then obtain a where "Q(a)" by (rule exE)
hence "P(a) ∨ Q(a)" by (rule disjI2)
thus "∃x. P(x) ∨ Q(x)" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_7_1b:
assumes "(∃x. P(x)) ∨ (∃x. Q(x))"
shows "∃x. P(x) ∨ Q(x)"
using assms
proof
assume "∃x. P(x)"
then obtain a where "P(a)" ..
hence "P(a) ∨ Q(a)" ..
thus "∃x. P(x) ∨ Q(x)" ..
next
assume "∃x. Q(x)"
then obtain a where "Q(a)" ..
hence "P(a) ∨ Q(a)" ..
thus "∃x. P(x) ∨ Q(x)" ..
qed

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

text {*
Ejemplo 7.2 (p. 22). Demostrar
∃x. P(x) ∨ Q(x) ⊢ (∃x. P(x)) ∨ (∃x. Q(x)) *}

-- "La demostración detallada es"
lemma ejemplo_7_2a:
assumes "∃x. P(x) ∨ Q(x)"
shows "(∃x. P(x)) ∨ (∃x. Q(x))"
proof -
obtain a where "P(a) ∨ Q(a)" using assms by (rule exE)
thus "(∃x. P(x)) ∨ (∃x. Q(x))"
proof (rule disjE)
assume "P(a)"
hence "∃x. P(x)" by (rule exI)
thus "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule disjI1)
next
assume "Q(a)"
hence "∃x. Q(x)" by (rule exI)
thus "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule disjI2)
qed
qed

-- "La demostración estructurada es"
lemma ejercicio_7_2b:
assumes "∃x. P(x) ∨ Q(x)"
shows "(∃x. P(x)) ∨ (∃x. Q(x))"
proof -
obtain a where "P(a) ∨ Q(a)" using assms ..
thus "(∃x. P(x)) ∨ (∃x. Q(x))"
proof
assume "P(a)"
hence "∃x. P(x)" ..
thus "(∃x. P(x)) ∨ (∃x. Q(x))" ..
next
assume "Q(a)"
hence "∃x. Q(x)" ..
thus "(∃x. P(x)) ∨ (∃x. Q(x))" ..
qed
qed

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

text {*
Ejemplo 7.3 (p. 23). Demostrar
⊢ ((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x)) *}

-- "La demostración detallada es"
lemma ejemplo_7_3a:
"((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x))"
proof (rule iffI)
assume "(∃x. P(x)) ∨ (∃x. Q(x))"
thus "∃x. P(x) ∨ Q(x)" by (rule ejemplo_7_1a)
next
assume "∃x. P(x) ∨ Q(x)"
thus "(∃x. P(x)) ∨ (∃x. Q(x))" by (rule ejemplo_7_2a)
qed

-- "La demostración automática es"
lemma ejemplo_7_3b:
"((∃x. P(x)) ∨ (∃x. Q(x))) ⟷ (∃x. P(x) ∨ Q(x))"
using assms
by auto

text {*
Ejemplo 8.1 (p. 24). Demostrar
∃x y. P(x,y) ⊢ ∃y x. P(x,y) *}

-- "La demostración detallada es"
lemma ejemplo_8_1a:
assumes "∃x y. P(x,y)"
shows "∃y x. P(x,y)"
proof -
obtain a where "∃y. P(a,y)" using assms by (rule exE)
then obtain b where "P(a,b)" by (rule exE)
hence "∃x. P(x,b)" by (rule exI)
thus "∃y x. P(x,y)" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_8_1b:
assumes "∃x y. P(x,y)"
shows "∃y x. P(x,y)"
proof -
obtain a where "∃y. P(a,y)" using assms ..
then obtain b where "P(a,b)" ..
hence "∃x. P(x,b)" ..
thus "∃y x. P(x,y)" ..
qed

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

text {*
Ejemplo 8.2. Demostrar
∃y x. P(x,y) ⊢ ∃x y. P(x,y) *}

-- "La demostración detallada es"
lemma ejemplo_8_2a:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
proof -
obtain b where "∃x. P(x,b)" using assms by (rule exE)
then obtain a where "P(a,b)" by (rule exE)
hence "∃y. P(a,y)" by (rule exI)
thus "∃x y. P(x,y)" by (rule exI)
qed

-- "La demostración estructurada es"
lemma ejemplo_8_2b:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
proof -
obtain b where "∃x. P(x,b)" using assms ..
then obtain a where "P(a,b)" ..
hence "∃y. P(a,y)" ..
thus "∃x y. P(x,y)" ..
qed

-- "La demostración estructurada es"
lemma ejemplo_8_2c:
assumes "∃y x. P(x,y)"
shows "∃x y. P(x,y)"
using assms
by auto

text {*
Ejemplo 8.3 (p. 25). Demostrar
⊢ (∃x y. P(x,y)) ⟷ (∃y x. P(x,y)) *}

-- "La demostración detallada es"
lemma ejemplo_8_3a:
"(∃x y. P(x,y)) ⟷ (∃y x. P(x,y))"
proof (rule iffI)
assume "∃x y. P(x,y)"
thus "∃y x. P(x,y)" by (rule ejemplo_8_1a)
next
assume "∃y x. P(x,y)"
thus "∃x y. P(x,y)" by (rule ejemplo_8_2a)
qed

-- "La demostración automática es"
lemma ejemplo_8_3b:
"(∃x y. P(x,y)) ⟷ (∃y x. P(x,y))"
by auto

section {* Reglas de la igualdad *}

text {*
Las reglas básicas de la igualdad son:
· refl: t = t
· subst: ⟦s = t; P s⟧ ⟹ P t
*}

text {*
Ejemplo 9 (p. 27). Demostrar
x+1 = 1+x, x+1 > 1 ⟶ x+1 > 0 ⊢ 1+x > 1 ⟶ 1+x > 0
*}

-- "La demostración detallada es"
lemma ejemplo_9a:
assumes "x+1 = 1+x"
"x+1 > 1 ⟶ x+1 > 0"
shows "1+x > 1 ⟶ 1+x > 0"
proof -
show "1+x > 1 ⟶ 1+x > 0" using assms by (rule subst)
qed

-- "La demostración estructurada es"
lemma ejemplo_9b:
assumes "x+1 = 1+x"
"x+1 > 1 ⟶ x+1 > 0"
shows "1+x > 1 ⟶ 1+x > 0"
using assms
by (rule subst)

-- "La demostración automática es"
lemma ejemplo_9c:
assumes "x+1 = 1+x"
"x+1 > 1 ⟶ x+1 > 0"
shows "1+x > 1 ⟶ 1+x > 0"
using assms
by auto

text {*
Ejemplo 10 (p. 27). Demostrar
x = y, y = z ⊢ x = z
*}

-- "La demostración detallada es"
lemma ejemplo_10a:
assumes "x = y"
"y = z"
shows "x = z"
proof -
show "x = z" using assms(2,1) by (rule subst)
qed

-- "La demostración estructurada es"
lemma ejemplo_10b:
assumes "x = y"
"y = z"
shows "x = z"
using assms(2,1)
by (rule subst)

-- "La demostración automática es"
lemma ejemplo_10c:
assumes "x = y"
"y = z"
shows "x = z"
using assms
by auto

text {*
Ejemplo 11 (p. 28). Demostrar
s = t ⊢ t = s
*}

-- "La demostración detallada es"
lemma ejemplo_11a:
assumes "s = t"
shows "t = s"
proof -
have "s = s" by (rule refl)
with assms show "t = s" by (rule subst)
qed

-- "La demostración automática es"
lemma ejemplo_11b:
assumes "s = t"
shows "t = s"
using assms
by auto

end
</source>

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

2017-01-12T06:51:16Z

Jalonso:

<source lang="isar">
chapter {* Tema 8b: Deducción natural proposicional con Isabelle/HOL *}

theory T8b_Deduccion_natural_en_logica_proposicional_con_Isabelle
imports Main
begin

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

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

subsection {* Reglas de la conjunción *}

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

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

text {*
Notas sobre el lenguaje: En la demostración anterior se ha usado
· "assumes" para indicar las hipótesis,
· "and" para separar las hipótesis,
· "shows" para indicar la conclusión,
· "proof" para iniciar la prueba,
· "qed" para terminar la pruebas,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "using" para usar hechos en un paso,
· "by (rule ..)" para indicar la regla con la que se peueba un hecho,
· "show" para establecer la conclusión.

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

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

lemma ejemplo_1_2:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 ..
show 4: "q ∧ r" using 3 2 ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· ".." para indicar que se prueba por la regla correspondiente. *}

text {* Se pueden eliminar las etiquetas como sigue *}

lemma ejemplo_1_3:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof -
have "q" using assms(1) ..
thus "q ∧ r" using assms(2) ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms(n)" para indicar la hipótesis n y
· "thus" para demostrar la conclusión usando el hecho anterior.
Además, no es necesario usar and entre las hipótesis. *}

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

lemma ejemplo_1_4:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms
by auto

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms" para indicar las hipótesis y
· "by auto" para demostrar la conclusión automáticamente. *}

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

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

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

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

lemma ejemplo_1_6:
assumes "p ∧ q"
and "r"
shows "q ∧ r"
proof (rule conjI)
show "q" using assms(1) by (rule conjunct2)
next
show "r" using assms(2) by this
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "proof (rule r)" para indicar que se hará la demostración con la
regla r,
· "next" para indicar el comienzo de la prueba del siguiente
subobjetivo,
· "this" para indicar el hecho actual. *}

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

lemma ejemplo_1_7:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof
show "q" using assms(1) ..
next
show "r" using assms(2) .
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "." para indicar por el hecho actual. *}

subsection {* Reglas de la doble negación *}

text {*
La regla de eliminación de la doble negación es
· notnotD: ¬¬ P ⟹ P

Para ajustarnos al tema de LI vamos a introducir la siguiente regla de
introducción de la doble negación
· notnotI: P ⟹ ¬¬ P
aunque, de momento, no detallamos su demostración.
*}

lemma notnotI [intro!]: "P ⟹ ¬¬ P"
by auto

text {*
Ejemplo 2. (p. 5)
p, ¬¬(q ∧ r) ⊢ ¬¬p ∧ r
*}

-- "La demostración detallada es"
lemma ejemplo_2_1:
assumes 1: "p" and
2: "¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have 3: "¬¬p" using 1 by (rule notnotI)
have 4: "q ∧ r" using 2 by (rule notnotD)
have 5: "r" using 4 by (rule conjunct2)
show 6: "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

-- "La demostración estructurada es"
lemma ejemplo_2_2:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have "¬¬p" using assms(1) ..
have "q ∧ r" using assms(2) by (rule notnotD)
hence "r" ..
with `¬¬p` show "¬¬p ∧ r" ..
qed

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

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

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

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

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

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

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

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

text {*
Ejemplo 3. (p. 6) Demostrar que
¬p ∧ q, ¬p ∧ q ⟶ r ∨ ¬p ⊢ r ∨ ¬p
*}

-- "La demostración detallada es"
lemma ejemplo_3_1:
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_3_2:
assumes "¬p ∧ q"
"¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using assms(2,1) ..
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_4_1:
assumes 1: "p" and
2: "p ⟶ q" and
3: "p ⟶ (q ⟶ r)"
shows "r"
proof -
have 4: "q" using 2 1 by (rule mp)
have 5: "q ⟶ r" using 3 1 by (rule mp)
show 6: "r" using 5 4 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_4_2:
assumes "p"
"p ⟶ q"
"p ⟶ (q ⟶ r)"
shows "r"
proof -
have "q" using assms(2,1) ..
have "q ⟶ r" using assms(3,1) ..
thus "r" using `q` ..
qed

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

subsection {* Regla derivada del modus tollens *}

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

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

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

-- "La demostración detallada es"
lemma ejemplo_5_1:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof -
have 4: "q ⟶ r" using 1 2 by (rule mp)
show "¬q" using 4 3 by (rule mt)
qed

-- "La demostración estructurada es"
lemma ejemplo_5_2:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
proof -
have "q ⟶ r" using assms(1,2) ..
thus "¬q" using assms(3) by (rule mt)
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_6_1:
assumes 1: "¬p ⟶ q" and
2: "¬q"
shows "p"
proof -
have 3: "¬¬p" using 1 2 by (rule mt)
show "p" using 3 by (rule notnotD)
qed

-- "La demostración estructurada es"
lemma ejemplo_6_2:
assumes "¬p ⟶ q"
"¬q"
shows "p"
proof -
have "¬¬p" using assms(1,2) by (rule mt)
thus "p" by (rule notnotD)
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_7_1:
assumes 1: "p ⟶ ¬q" and
2: "q"
shows "¬p"
proof -
have 3: "¬¬q" using 2 by (rule notnotI)
show "¬p" using 1 3 by (rule mt)
qed

-- "La demostración detallada es"
lemma ejemplo_7_2:
assumes "p ⟶ ¬q"
"q"
shows "¬p"
proof -
have "¬¬q" using assms(2) by (rule notnotI)
with assms(1) show "¬p" by (rule mt)
qed

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_8_1:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 2: "¬q"
have "¬p" using 1 2 by (rule mt) }
thus "¬q ⟶ ¬p" by (rule impI)
qed

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_9_1:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof -
{ assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt) }
thus "p ⟶ ¬¬q" by (rule impI)
qed

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

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

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

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_11_1:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof -
{ assume 1: "q ⟶ r"
{ assume 2: "¬q ⟶ ¬p"
{ assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
have "r" using 1 6 by (rule mp) }
hence "p ⟶ r" by (rule impI) }
hence "(¬q ⟶ ¬p) ⟶ p ⟶ r" by (rule impI) }
thus "(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ p ⟶ r)" by (rule impI)
qed

-- "La demostración hacia atrás es"
lemma ejemplo_11_2:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 by (rule mp)
qed
qed
qed

-- "La demostración hacia atrás con reglas implícitas es"
lemma ejemplo_11_3:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume 3: "p"
have 4: "¬¬p" using 3 ..
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 ..
qed
qed
qed

-- "La demostración sin etiquetas es"
lemma ejemplo_11_4:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume "p"
hence "¬¬p" ..
with `¬q ⟶ ¬p` have "¬¬q" by (rule mt)
hence "q" by (rule notnotD)
with `q ⟶ r` show "r" ..
qed
qed
qed

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

subsection {* Reglas de la disyunción *}

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

text {*
Ejemplo 12 (p. 11). Demostrar
p ∨ q ⊢ q ∨ p
*}

-- "La demostración detallada es"
lemma ejemplo_12_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms by this
moreover
{ assume 2: "p"
have "q ∨ p" using 2 by (rule disjI2) }
moreover
{ assume 3: "q"
have "q ∨ p" using 3 by (rule disjI1) }
ultimately show "q ∨ p" by (rule disjE)
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "moreover" para separar los bloques y
· "ultimately" para unir los resultados de los bloques. *}

-- "La demostración detallada con reglas implícitas es"
lemma ejemplo_12_2:
assumes "p ∨ q"
shows "q ∨ p"
proof -
note `p ∨ q`
moreover
{ assume "p"
hence "q ∨ p" .. }
moreover
{ assume "q"
hence "q ∨ p" .. }
ultimately show "q ∨ p" ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "note" para copiar un hecho. *}

-- "La demostración hacia atrás es"
lemma ejemplo_12_3:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1
proof (rule disjE)
{ assume 2: "p"
show "q ∨ p" using 2 by (rule disjI2) }
next
{ assume 3: "q"
show "q ∨ p" using 3 by (rule disjI1) }
qed

-- "La demostración hacia atrás con reglas implícitas es"
lemma ejemplo_12_4:
assumes "p ∨ q"
shows "q ∨ p"
using assms
proof
{ assume "p"
thus "q ∨ p" .. }
next
{ assume "q"
thus "q ∨ p" .. }
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_13_1:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q"
thus "p ∨ r"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ r" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "r" using 1 4 by (rule mp)
show "p ∨ r" using 5 by (rule disjI2) }
qed
qed

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

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

subsection {* Regla de copia *}

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

-- "La demostración detallada es"
lemma ejemplo_14_1:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using 1 by this
qed
qed

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

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

subsection {* Reglas de la negación *}

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

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

-- "La demostración detallada es"
lemma ejemplo_15_1:
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p"
note 1
thus "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume 4: "q"
show "q" using 4 by this}
qed
qed

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

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

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

-- "La demostración detallada es"
lemma ejemplo_16_1:
assumes 1: "p ⟶ q" and
2: "p ⟶ ¬q"
shows "¬p"
proof (rule notI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "¬q" using 2 3 by (rule mp)
show False using 5 4 by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_16_2:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
proof
assume "p"
have "q" using assms(1) `p` ..
have "¬q" using assms(2) `p` ..
thus False using `q` ..
qed

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

subsection {* Reglas del bicondicional *}

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

text {*
Ejemplo 17 (p. 17) Demostrar
(p ∧ q) ⟷ (q ∧ p)
*}

-- "La demostración detallada es"
lemma ejemplo_17_1:
"(p ∧ q) ⟷ (q ∧ p)"
proof (rule iffI)
{ assume 1: "p ∧ q"
have 2: "p" using 1 by (rule conjunct1)
have 3: "q" using 1 by (rule conjunct2)
show "q ∧ p" using 3 2 by (rule conjI) }
next
{ assume 4: "q ∧ p"
have 5: "q" using 4 by (rule conjunct1)
have 6: "p" using 4 by (rule conjunct2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

-- "La demostración estructurada es"
lemma ejemplo_17_2:
"(p ∧ q) ⟷ (q ∧ p)"
proof
{ assume 1: "p ∧ q"
have "p" using 1 ..
have "q" using 1 ..
show "q ∧ p" using `q` `p` .. }
next
{ assume 2: "q ∧ p"
have "q" using 2 ..
have "p" using 2 ..
show "p ∧ q" using `p` `q` .. }
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_18_1:
assumes 1: "p ⟷ q" and
2: "p ∨ q"
shows "p ∧ q"
using 2
proof (rule disjE)
{ assume 3: "p"
have 4: "q" using 1 3 by (rule iffD1)
show "p ∧ q" using 3 4 by (rule conjI) }
next
{ assume 5: "q"
have 6: "p" using 1 5 by (rule iffD2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

-- "La demostración estructurada es"
lemma ejemplo_18_2:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms(2)
proof
{ assume "p"
with assms(1) have "q" ..
with `p` show "p ∧ q" .. }
next
{ assume "q"
with assms(1) have "p" ..
thus "p ∧ q" using `q` .. }
qed

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

subsection {* Reglas derivadas *}

subsubsection {* Regla del modus tollens *}

text {*
Ejemplo 19 (p. 20) Demostrar la regla del modus tollens a partir de
las reglas básicas.
*}

-- "La demostración detallada es"
lemma ejemplo_20_1:
assumes 1: "F ⟶ G" and
2: "¬G"
shows "¬F"
proof (rule notI)
assume 3: "F"
have 4: "G" using 1 3 by (rule mp)
show False using 2 4 by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_20_2:
assumes "F ⟶ G"
"¬G"
shows "¬F"
proof
assume "F"
with assms(1) have "G" ..
with assms(2) show False ..
qed

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

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

text {*
Ejemplo 21 (p. 21) Demostrar la regla de introducción de la doble
negación a partir de las reglas básicas.
*}

-- "La demostración detallada es"
lemma ejemplo_21_1:
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

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

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

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

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

subsubsection {* Ley del tercio excluso *}

text {*
La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
*}

text {*
Ejemplo 22 (p. 23). Demostrar la ley del tercio excluso a partir de
las reglas básicas.
*}

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

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

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

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

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

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

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

subsection {* Demostraciones por contradicción *}

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

-- "La demostración detallada es"
lemma ejemplo_24_1:
assumes "¬p"
"p ∨ q"
shows "q"
using `p ∨ q`
proof (rule disjE)
assume "p"
with assms(1) show "q" by contradiction
next
assume "q"
thus "q" by assumption
qed

-- "La demostración estructurada es"
lemma ejemplo_24_2:
assumes "¬p"
"p ∨ q"
shows "q"
using `p ∨ q`
proof
assume "p"
with assms(1) show "q" ..
next
assume "q"
thus "q" .
qed

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

end
</source>

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

2017-01-12T06:50:32Z

Jalonso: Página creada con '<source lang="isar"> chapter {* Tema 7b: Deducción natural proposicional con Isabelle/HOL *} theory T8b_Deduccion_natural_en_logica_proposicional_con_Isabelle imports Main be...'

<source lang="isar">
chapter {* Tema 7b: Deducción natural proposicional con Isabelle/HOL *}

theory T8b_Deduccion_natural_en_logica_proposicional_con_Isabelle
imports Main
begin

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

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

subsection {* Reglas de la conjunción *}

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

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

text {*
Notas sobre el lenguaje: En la demostración anterior se ha usado
· "assumes" para indicar las hipótesis,
· "and" para separar las hipótesis,
· "shows" para indicar la conclusión,
· "proof" para iniciar la prueba,
· "qed" para terminar la pruebas,
· "-" (después de "proof") para no usar el método por defecto,
· "have" para establecer un paso,
· "using" para usar hechos en un paso,
· "by (rule ..)" para indicar la regla con la que se peueba un hecho,
· "show" para establecer la conclusión.

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

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

lemma ejemplo_1_2:
assumes 1: "p ∧ q" and
2: "r"
shows "q ∧ r"
proof -
have 3: "q" using 1 ..
show 4: "q ∧ r" using 3 2 ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· ".." para indicar que se prueba por la regla correspondiente. *}

text {* Se pueden eliminar las etiquetas como sigue *}

lemma ejemplo_1_3:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof -
have "q" using assms(1) ..
thus "q ∧ r" using assms(2) ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms(n)" para indicar la hipótesis n y
· "thus" para demostrar la conclusión usando el hecho anterior.
Además, no es necesario usar and entre las hipótesis. *}

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

lemma ejemplo_1_4:
assumes "p ∧ q"
"r"
shows "q ∧ r"
using assms
by auto

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "assms" para indicar las hipótesis y
· "by auto" para demostrar la conclusión automáticamente. *}

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

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

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

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

lemma ejemplo_1_6:
assumes "p ∧ q"
and "r"
shows "q ∧ r"
proof (rule conjI)
show "q" using assms(1) by (rule conjunct2)
next
show "r" using assms(2) by this
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "proof (rule r)" para indicar que se hará la demostración con la
regla r,
· "next" para indicar el comienzo de la prueba del siguiente
subobjetivo,
· "this" para indicar el hecho actual. *}

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

lemma ejemplo_1_7:
assumes "p ∧ q"
"r"
shows "q ∧ r"
proof
show "q" using assms(1) ..
next
show "r" using assms(2) .
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "." para indicar por el hecho actual. *}

subsection {* Reglas de la doble negación *}

text {*
La regla de eliminación de la doble negación es
· notnotD: ¬¬ P ⟹ P

Para ajustarnos al tema de LI vamos a introducir la siguiente regla de
introducción de la doble negación
· notnotI: P ⟹ ¬¬ P
aunque, de momento, no detallamos su demostración.
*}

lemma notnotI [intro!]: "P ⟹ ¬¬ P"
by auto

text {*
Ejemplo 2. (p. 5)
p, ¬¬(q ∧ r) ⊢ ¬¬p ∧ r
*}

-- "La demostración detallada es"
lemma ejemplo_2_1:
assumes 1: "p" and
2: "¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have 3: "¬¬p" using 1 by (rule notnotI)
have 4: "q ∧ r" using 2 by (rule notnotD)
have 5: "r" using 4 by (rule conjunct2)
show 6: "¬¬p ∧ r" using 3 5 by (rule conjI)
qed

-- "La demostración estructurada es"
lemma ejemplo_2_2:
assumes "p"
"¬¬(q ∧ r)"
shows "¬¬p ∧ r"
proof -
have "¬¬p" using assms(1) ..
have "q ∧ r" using assms(2) by (rule notnotD)
hence "r" ..
with `¬¬p` show "¬¬p ∧ r" ..
qed

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

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

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

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

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

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

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

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

text {*
Ejemplo 3. (p. 6) Demostrar que
¬p ∧ q, ¬p ∧ q ⟶ r ∨ ¬p ⊢ r ∨ ¬p
*}

-- "La demostración detallada es"
lemma ejemplo_3_1:
assumes 1: "¬p ∧ q" and
2: "¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using 2 1 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_3_2:
assumes "¬p ∧ q"
"¬p ∧ q ⟶ r ∨ ¬p"
shows "r ∨ ¬p"
proof -
show "r ∨ ¬p" using assms(2,1) ..
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_4_1:
assumes 1: "p" and
2: "p ⟶ q" and
3: "p ⟶ (q ⟶ r)"
shows "r"
proof -
have 4: "q" using 2 1 by (rule mp)
have 5: "q ⟶ r" using 3 1 by (rule mp)
show 6: "r" using 5 4 by (rule mp)
qed

-- "La demostración estructurada es"
lemma ejemplo_4_2:
assumes "p"
"p ⟶ q"
"p ⟶ (q ⟶ r)"
shows "r"
proof -
have "q" using assms(2,1) ..
have "q ⟶ r" using assms(3,1) ..
thus "r" using `q` ..
qed

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

subsection {* Regla derivada del modus tollens *}

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

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

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

-- "La demostración detallada es"
lemma ejemplo_5_1:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p" and
3: "¬r"
shows "¬q"
proof -
have 4: "q ⟶ r" using 1 2 by (rule mp)
show "¬q" using 4 3 by (rule mt)
qed

-- "La demostración estructurada es"
lemma ejemplo_5_2:
assumes "p ⟶ (q ⟶ r)"
"p"
"¬r"
shows "¬q"
proof -
have "q ⟶ r" using assms(1,2) ..
thus "¬q" using assms(3) by (rule mt)
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_6_1:
assumes 1: "¬p ⟶ q" and
2: "¬q"
shows "p"
proof -
have 3: "¬¬p" using 1 2 by (rule mt)
show "p" using 3 by (rule notnotD)
qed

-- "La demostración estructurada es"
lemma ejemplo_6_2:
assumes "¬p ⟶ q"
"¬q"
shows "p"
proof -
have "¬¬p" using assms(1,2) by (rule mt)
thus "p" by (rule notnotD)
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_7_1:
assumes 1: "p ⟶ ¬q" and
2: "q"
shows "¬p"
proof -
have 3: "¬¬q" using 2 by (rule notnotI)
show "¬p" using 1 3 by (rule mt)
qed

-- "La demostración detallada es"
lemma ejemplo_7_2:
assumes "p ⟶ ¬q"
"q"
shows "¬p"
proof -
have "¬¬q" using assms(2) by (rule notnotI)
with assms(1) show "¬p" by (rule mt)
qed

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_8_1:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof -
{ assume 2: "¬q"
have "¬p" using 1 2 by (rule mt) }
thus "¬q ⟶ ¬p" by (rule impI)
qed

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_9_1:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ ¬¬q"
proof -
{ assume 2: "p"
have 3: "¬¬p" using 2 by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt) }
thus "p ⟶ ¬¬q" by (rule impI)
qed

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

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

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

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

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

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

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

-- "La demostración detallada es"
lemma ejemplo_11_1:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof -
{ assume 1: "q ⟶ r"
{ assume 2: "¬q ⟶ ¬p"
{ assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
have "r" using 1 6 by (rule mp) }
hence "p ⟶ r" by (rule impI) }
hence "(¬q ⟶ ¬p) ⟶ p ⟶ r" by (rule impI) }
thus "(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ p ⟶ r)" by (rule impI)
qed

-- "La demostración hacia atrás es"
lemma ejemplo_11_2:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "¬¬p" using 3 by (rule notnotI)
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 by (rule mp)
qed
qed
qed

-- "La demostración hacia atrás con reglas implícitas es"
lemma ejemplo_11_3:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume 1: "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume 2: "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume 3: "p"
have 4: "¬¬p" using 3 ..
have 5: "¬¬q" using 2 4 by (rule mt)
have 6: "q" using 5 by (rule notnotD)
show "r" using 1 6 ..
qed
qed
qed

-- "La demostración sin etiquetas es"
lemma ejemplo_11_4:
"(q ⟶ r) ⟶ ((¬q ⟶ ¬p) ⟶ (p ⟶ r))"
proof
assume "q ⟶ r"
show "(¬q ⟶ ¬p) ⟶ (p ⟶ r)"
proof
assume "¬q ⟶ ¬p"
show "p ⟶ r"
proof
assume "p"
hence "¬¬p" ..
with `¬q ⟶ ¬p` have "¬¬q" by (rule mt)
hence "q" by (rule notnotD)
with `q ⟶ r` show "r" ..
qed
qed
qed

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

subsection {* Reglas de la disyunción *}

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

text {*
Ejemplo 12 (p. 11). Demostrar
p ∨ q ⊢ q ∨ p
*}

-- "La demostración detallada es"
lemma ejemplo_12_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms by this
moreover
{ assume 2: "p"
have "q ∨ p" using 2 by (rule disjI2) }
moreover
{ assume 3: "q"
have "q ∨ p" using 3 by (rule disjI1) }
ultimately show "q ∨ p" by (rule disjE)
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "moreover" para separar los bloques y
· "ultimately" para unir los resultados de los bloques. *}

-- "La demostración detallada con reglas implícitas es"
lemma ejemplo_12_2:
assumes "p ∨ q"
shows "q ∨ p"
proof -
note `p ∨ q`
moreover
{ assume "p"
hence "q ∨ p" .. }
moreover
{ assume "q"
hence "q ∨ p" .. }
ultimately show "q ∨ p" ..
qed

text {*
Nota sobre el lenguaje: En la demostración anterior se ha usado
· "note" para copiar un hecho. *}

-- "La demostración hacia atrás es"
lemma ejemplo_12_3:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1
proof (rule disjE)
{ assume 2: "p"
show "q ∨ p" using 2 by (rule disjI2) }
next
{ assume 3: "q"
show "q ∨ p" using 3 by (rule disjI1) }
qed

-- "La demostración hacia atrás con reglas implícitas es"
lemma ejemplo_12_4:
assumes "p ∨ q"
shows "q ∨ p"
using assms
proof
{ assume "p"
thus "q ∨ p" .. }
next
{ assume "q"
thus "q ∨ p" .. }
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_13_1:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q"
thus "p ∨ r"
proof (rule disjE)
{ assume 3: "p"
show "p ∨ r" using 3 by (rule disjI1) }
next
{ assume 4: "q"
have 5: "r" using 1 4 by (rule mp)
show "p ∨ r" using 5 by (rule disjI2) }
qed
qed

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

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

subsection {* Regla de copia *}

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

-- "La demostración detallada es"
lemma ejemplo_14_1:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume "q"
show "p" using 1 by this
qed
qed

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

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

subsection {* Reglas de la negación *}

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

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

-- "La demostración detallada es"
lemma ejemplo_15_1:
assumes 1: "¬p ∨ q"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p"
note 1
thus "q"
proof (rule disjE)
{ assume 3: "¬p"
show "q" using 3 2 by (rule notE) }
next
{ assume 4: "q"
show "q" using 4 by this}
qed
qed

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

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

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

-- "La demostración detallada es"
lemma ejemplo_16_1:
assumes 1: "p ⟶ q" and
2: "p ⟶ ¬q"
shows "¬p"
proof (rule notI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "¬q" using 2 3 by (rule mp)
show False using 5 4 by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_16_2:
assumes "p ⟶ q"
"p ⟶ ¬q"
shows "¬p"
proof
assume "p"
have "q" using assms(1) `p` ..
have "¬q" using assms(2) `p` ..
thus False using `q` ..
qed

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

subsection {* Reglas del bicondicional *}

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

text {*
Ejemplo 17 (p. 17) Demostrar
(p ∧ q) ⟷ (q ∧ p)
*}

-- "La demostración detallada es"
lemma ejemplo_17_1:
"(p ∧ q) ⟷ (q ∧ p)"
proof (rule iffI)
{ assume 1: "p ∧ q"
have 2: "p" using 1 by (rule conjunct1)
have 3: "q" using 1 by (rule conjunct2)
show "q ∧ p" using 3 2 by (rule conjI) }
next
{ assume 4: "q ∧ p"
have 5: "q" using 4 by (rule conjunct1)
have 6: "p" using 4 by (rule conjunct2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

-- "La demostración estructurada es"
lemma ejemplo_17_2:
"(p ∧ q) ⟷ (q ∧ p)"
proof
{ assume 1: "p ∧ q"
have "p" using 1 ..
have "q" using 1 ..
show "q ∧ p" using `q` `p` .. }
next
{ assume 2: "q ∧ p"
have "q" using 2 ..
have "p" using 2 ..
show "p ∧ q" using `p` `q` .. }
qed

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

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

-- "La demostración detallada es"
lemma ejemplo_18_1:
assumes 1: "p ⟷ q" and
2: "p ∨ q"
shows "p ∧ q"
using 2
proof (rule disjE)
{ assume 3: "p"
have 4: "q" using 1 3 by (rule iffD1)
show "p ∧ q" using 3 4 by (rule conjI) }
next
{ assume 5: "q"
have 6: "p" using 1 5 by (rule iffD2)
show "p ∧ q" using 6 5 by (rule conjI) }
qed

-- "La demostración estructurada es"
lemma ejemplo_18_2:
assumes "p ⟷ q"
"p ∨ q"
shows "p ∧ q"
using assms(2)
proof
{ assume "p"
with assms(1) have "q" ..
with `p` show "p ∧ q" .. }
next
{ assume "q"
with assms(1) have "p" ..
thus "p ∧ q" using `q` .. }
qed

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

subsection {* Reglas derivadas *}

subsubsection {* Regla del modus tollens *}

text {*
Ejemplo 19 (p. 20) Demostrar la regla del modus tollens a partir de
las reglas básicas.
*}

-- "La demostración detallada es"
lemma ejemplo_20_1:
assumes 1: "F ⟶ G" and
2: "¬G"
shows "¬F"
proof (rule notI)
assume 3: "F"
have 4: "G" using 1 3 by (rule mp)
show False using 2 4 by (rule notE)
qed

-- "La demostración estructurada es"
lemma ejemplo_20_2:
assumes "F ⟶ G"
"¬G"
shows "¬F"
proof
assume "F"
with assms(1) have "G" ..
with assms(2) show False ..
qed

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

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

text {*
Ejemplo 21 (p. 21) Demostrar la regla de introducción de la doble
negación a partir de las reglas básicas.
*}

-- "La demostración detallada es"
lemma ejemplo_21_1:
assumes 1: "F"
shows "¬¬F"
proof (rule notI)
assume 2: "¬F"
show False using 2 1 by (rule notE)
qed

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

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

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

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

subsubsection {* Ley del tercio excluso *}

text {*
La ley del tercio excluso es
· excluded_middle: ¬P ∨ P
*}

text {*
Ejemplo 22 (p. 23). Demostrar la ley del tercio excluso a partir de
las reglas básicas.
*}

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

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

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

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

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

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

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

subsection {* Demostraciones por contradicción *}

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

-- "La demostración detallada es"
lemma ejemplo_24_1:
assumes "¬p"
"p ∨ q"
shows "q"
using `p ∨ q`
proof (rule disjE)
assume "p"
with assms(1) show "q" by contradiction
next
assume "q"
thus "q" by assumption
qed

-- "La demostración estructurada es"
lemma ejemplo_24_2:
assumes "¬p"
"p ∨ q"
shows "q"
using `p ∨ q`
proof
assume "p"
with assms(1) show "q" ..
next
assume "q"
thus "q" .
qed

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

end
</source>

Temas

2017-01-12T06:46:02Z

Jalonso:

== Temas de ''Razonamiento automático (2016-17)'' ==

* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5: Razonamiento sobre árboles y bosques]].
* Tema 6: Verificación de algoritmos de ordenación:
** [[Tema 6a: Verificación de la ordenación por inserción]].
** [[Tema 6b: Verificación de la ordenación por mezcla]].
* [[Tema 7: Caso de estudio: Compilación de expresiones]].
* Tema 8: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7a: Deducción natural proposicional].
** [[Tema 8b: Deducción natural proposicional con Isabelle/HOL]].
* Tema 9: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 8a: Deducción natural en lógica de primer orden].
** [[Tema 9b: Deducción natural en lógica de primer orden con Isabelle/HOL]]

Temas

2017-01-12T06:45:08Z

Jalonso:

== Temas de ''Razonamiento automático (2016-17)'' ==

* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5: Razonamiento sobre árboles y bosques]].
* Tema 6: Verificación de algoritmos de ordenación:
** [[Tema 6a: Verificación de la ordenación por inserción]].
** [[Tema 6b: Verificación de la ordenación por mezcla]].
* [[Tema 7: Caso de estudio: Compilación de expresiones]].
* Tema 8: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7a: Deducción natural proposicional]].
** [[Tema 8b: Deducción natural proposicional con Isabelle/HOL]].
* Tema 9: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 8a: Deducción natural en lógica de primer orden]].
** [[Tema 9b: Deducción natural en lógica de primer orden con Isabelle/HOL]]

Relación 7

2017-01-03T07:17:03Z

Jalonso: Desprotegió «Relación 7»

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

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

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

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

(* fraortmoy marcarmor13 josgarsan fracorjim1 *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort pablucoto
ivamenjim serrodcal crigomgom rubgonmar danrodcha ferrenseg
manmorjim1 juacabsou lucnovdos dancorgar bowma *)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1"
| "hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

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

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort marcarmor13
dancorgar *)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort pablucoto ivamenjim serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou lucnovdos bowma *)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
| "profundidad2 (N i d) = 1 + (max (profundidad2 i) (profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b then a else b)"

fun profundidad3 :: "arbol => nat" where
"profundidad3 H = 0"
| "profundidad3 (N i d) = 1 + maximo (profundidad3 i, profundidad3 d)"

(* ivamenjim: llamando a la función anterior profundidad3 *)
lemma "profundidad a = profundidad3 a"
by (induct a) auto

(* ivamenjim manmorjim1 fracorjim1 *)
fun profundidad4 :: "arbol => nat" where
"profundidad4 H = 0"
| "profundidad4 (N i d) = Suc (max (profundidad4 i) (profundidad4 d))"

lemma "profundidad a = profundidad4 a"
by (induct a) auto

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

(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan
manmorjim1 juacabsou fracorjim1 lucnovdos dancorgar bowma *)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

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

(* ivamenjim pablucoto marcarmor13 *)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

value "abc2 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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

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

(* fraortmoy anaprarod migtermor serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan fracorjim1 lucnovdos bowma *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg ivamenjim pablucoto marcarmor13 manmorjim1
dancorgar *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True"
| "es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

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

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

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

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal
fracorjim1 josgarsan lucnovdos bowma *)
lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal
crigomgom rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg
juacabsou bowma *)
(* También funciona con AUX7 *)
lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

(* Comentario: Uso de la declaración simp *)

theorem es_abc_profundidad_hojas:
"es_abc profundidad a = es_abc hojas a"
by (induct a) auto

(* Comentario: Dependencia de la declaración simp. *)

(* dancorgar *)
lemma rel_hojas_prof: "es_abc hojas a ∧ es_abc profundidad a
⟹ hojas a = 2 ^ profundidad a"
by (induct a) (auto)

theorem "es_abc hojas a = es_abc profundidad a"
by (induct a) (auto simp add: rel_hojas_prof)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal
marcarmor13 josgarsan lucnovdos bowma *)
lemma abc_hojas_num_nodos:
assumes "es_abc hojas a"
shows "Suc (size a) = hojas a"
using assms
by (induct a) auto

(* Comentario sobre orientación de igualdades. *)

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom paupeddeg juacabsou rubgonmar *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto
serrodcal *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* Comentario sobre orientación de igualdades. *)

(* anaprarod crigomgom paupeddeg juacabsou rubgonmar *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: AUX8)

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8b: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

(* fracorjim1 *)
lemma aux10 : "hojas (a::arbol) = Suc(size a)"
apply (induct a)
apply auto
done

lemma es_abc_hojas_size_10 : "es_abc hojas (a::arbol) = es_abc size a"
apply (induct a)
apply (auto simp add: aux10)
done

(* dancorgar *)
lemma rel_hojas_size: "es_abc hojas a ∧ es_abc size a
⟹ hojas a = (size a) + 1"
by (induct a) (auto)

theorem "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: rel_hojas_size)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13
paupeddeg juacabsou josgarsan bowma lucnovdos *)
lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

(* ferrenseg *)
corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal
crigomgom marcarmor13 paupeddeg juacabsou dancorgar lucnovdos *)
lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou bowma*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10b: "es_abc f (abc n)"
by (induct n) auto

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal
marcarmor13 *)
lemma lej11:
assumes "es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou
dancorgar bowma lucnovdos *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a = N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort pablucoto serrodcal danrodcha marcarmor13
ferrenseg ivamenjim paupeddeg juacabsou rubgonmar bowma lucnovdos *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0
pero he usado una expresión lambda *)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

(* dancorgar *)
fun medida :: "arbol => bool" where
"medida H = True"
| "medida (N i d) = ((profundidad i) = (size d))"

theorem "es_abc size a = es_abc medida a"
quickcheck
oops

end
</source>

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

2016-12-22T11:37:03Z

Jalonso: Protegió «Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

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

theory T2b_Razonamiento_automatico_sobre_programas_en_IsabelleHOL
imports Main
begin

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

text {*
Se usarán nombres cortos. *}

declare [[names_short]]

section {* Razonamiento ecuacional *}

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

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

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

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

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

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

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejemplo 6. (p. 9) Demostrar que
inversa [x] = [x]
------------------------------------------------------------------- *}

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

section {* Razonamiento por inducción sobre los naturales *}

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

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

thm nat.induct

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

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

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

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

(* 1ª demostración (procedimental) *)
lemma "longitud (repite n x) = n"
apply (induct n)
apply auto
done

(* 2ª demostración (declarativa) *)
lemma "longitud (repite n x) = n"
by (induct n) auto

section {* Razonamiento por inducción sobre listas *}

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

En Isabelle el principio de inducción sobre listas está formalizado
mediante el teorema list.induct que puede verse con
thm list.induct
*}

thm list.induct

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

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

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

text {* ---------------------------------------------------------------
Ejemplo 10. (p. 24) Demostrar que
conc xs (conc ys zs) = (conc xs ys) zs
------------------------------------------------------------------- *}

(* 1ª demostración *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
apply (induct xs)
apply auto
done

(* 2ª demostración *)
lemma "conc xs (conc ys zs) = conc (conc xs ys) zs"
by (induct xs) auto

text {* ---------------------------------------------------------------
Ejemplo 11. Refutar que
conc xs ys = conc ys xs
------------------------------------------------------------------- *}

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

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

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

(* 1ª demostración *)
lemma "conc xs [] = xs"
apply (induct xs)
apply auto
done

(* 2ª demostración *)
lemma "conc xs [] = xs"
by (induct xs) auto

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

(* 1ª demostración *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
apply (induct xs)
apply auto
done

(* 2ª demostración *)
lemma "longitud (conc xs ys) = longitud xs + longitud ys"
by (induct xs) auto

section {* Inducción correspondiente a la definición recursiva *}

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

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

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

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

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

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

text {*
La definición coge genera el esquema de inducción coge.induct:
⟦⋀n. P n [];
⋀x xs. P 0 (x#xs);
⋀n x xs. P n xs ⟹ P (Suc n) (x#xs)⟧
⟹ P n x

Puede verse usando "thm coge.induct". *}

thm coge.induct

text {* ---------------------------------------------------------------
Ejemplo 16. (p. 35) Demostrar que
conc (coge n xs) (elimina n xs) = xs
------------------------------------------------------------------- *}

(* 1ª demostración *)
lemma "conc (coge n xs) (elimina n xs) = xs"
apply (induct rule: coge.induct)
apply auto
done

(* 2ª demostración *)
lemma "conc (coge n xs) (elimina n xs) = xs"
by (induct rule: coge.induct) auto

section {* Razonamiento por casos *}

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

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

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

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

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

(* 1ª demostración *)
lemma "esVacia xs = esVacia (conc xs xs)"
apply (cases xs)
apply auto
done

(* 2ª demostración *)
lemma "esVacia xs = esVacia (conc xs xs)"
by (cases xs) auto

section {* Heurística de generalización *}

text {*
Heurística de generalización: Cuando se use demostración estructural,
cuantificar universalmente las variables libres (o, equivalentemente,
considerar las variables libres como variables arbitrarias). *}

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

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

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

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

text {* ---------------------------------------------------------------
Ejemplo 20. (p. 44) Demostrar que
inversaAcAux xs ys = (inversa xs) @ ys
------------------------------------------------------------------- *}

(* 1ª demostración *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs)@ys"
apply (induct xs arbitrary: ys)
apply auto
done

(* 2ª demostración *)
lemma inversaAcAux_es_inversa:
"inversaAcAux xs ys = (inversa xs)@ys"
by (induct xs arbitrary: ys) auto

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

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

section {* Demostración por inducción para funciones de orden superior *}

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejemplo 24. (p. 45) Demostrar que
sum (map (λx. 2*x) xs) = 2 * (sum xs)
------------------------------------------------------------------- *}

(* 1ª demostración *)
lemma "sum (map (λx. 2*x) xs) = 2 * (sum xs)"
apply (induct xs)
apply auto
done

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

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

(* 1ª demostración *)
lemma "longitud (map f xs) = longitud xs"
apply (induct xs)
apply auto
done

(* 2ª demostración *)
lemma "longitud (map f xs) = longitud xs"
by (induct xs) auto

section {* Referencias *}

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

end
</source>

Tema 5: Razonamiento sobre árboles y bosques

2016-12-22T11:36:35Z

Jalonso: Protegió «Tema 5: Razonamiento sobre árboles y bosques» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

<source lang="isar">
chapter {* Tema 5: Razonamiento sobre árboles *}

theory T5_Razonamiento_sobre_arboles
imports Main Parity
begin

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

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

section {* Razonamiento sobre árboles binarios *}

text {*
Ejemplo de definición de tipos recursivos:
Definir un tipo de dato para los árboles binarios.
*}

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

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

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

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

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

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

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

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

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

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

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

text {*
Ejemplo. [Aplanamiento de la imagen especular] Demostrar que
aplana (espejo a) = rev (aplana a)
*}

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

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

section {* Árboles y bosques. Recursión mutua e inducción *}

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

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

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

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

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

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

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

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

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

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

end
</source>

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

2016-12-22T11:36:22Z

Jalonso: Protegió «Tema 6a: Verificación de la ordenación por inserción» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

<source lang="isar">
chapter {* T6a: Verificación de la ordenación por inserción *}

theory T6a_Verificacion_de_la_ordenacion_por_insercion
imports Main
begin

text {*
En este de tema se define el algoritmo de ordenación de listas
por inserción y se demuestra que es correcto. *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

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

2016-12-22T11:36:10Z

Jalonso: Protegió «Tema 6b: Verificación de la ordenación por mezcla» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

<source lang="isar">
chapter {* T6b: Verificación de la ordenación por mezcla *}

theory T6b_Verificacion_de_la_ordenacion_por_mezcla_sol
imports Main
begin

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

section {* Ordenación de listas *}

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

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

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

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

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

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

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

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

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

section {* Ordenación por mezcla *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que si x es mayor que 1, entonces el mínimo de
x y su mitad es menor que x.
------------------------------------------------------------------ *}

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

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

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

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

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

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

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

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

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

end
</source>

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

2016-12-22T11:35:58Z

Jalonso: Protegió «Tema 7: Caso de estudio: Compilación de expresiones» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

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

theory T7_Caso_de_estudio_Compilacion_de_expresiones

imports Main
begin

declare [[names_short]]

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

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

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

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

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

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

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

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

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

section {* La máquina de pila *}

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

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

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

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

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

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

section {* El compilador *}

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

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

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

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

section {* Corrección del compilador *}

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

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

2016-12-22T11:35:49Z

Jalonso: Página creada con '<source lang="isar"> chapter {* Tema 7: Caso de estudio: Compilación de expresiones *} theory T7_Caso_de_estudio_Compilacion_de_expresiones imports Main begin declare [[name...'

Temas

2016-12-22T11:34:33Z

Jalonso:

== Temas de ''Razonamiento automático (2016-17)'' ==

* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5: Razonamiento sobre árboles y bosques]].
* Tema 6: Verificación de algoritmos de ordenación:
** [[Tema 6a: Verificación de la ordenación por inserción]].
** [[Tema 6b: Verificación de la ordenación por mezcla]].
* [[Tema 7: Caso de estudio: Compilación de expresiones]].

Relación 7

2016-12-22T08:26:54Z

Jalonso:

Relación 7

2016-12-22T08:00:48Z

Jalonso: Protegió «Relación 7» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

<source lang="isar">
chapter {* R7: Árboles binarios completos *}

theory R7_Arboles_binarios_completos
imports Main
begin

text {*
En esta relación se piden demostraciones automáticas (lo más cortas
posibles). Para ello, en algunos casos es necesario incluir lemas
auxiliares (que se demuestran automáticamente) y usar ejercicios
anteriores.

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

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H) = (N (N H H) (N H H) :: arbol)"

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

(* fraortmoy marcarmor13 josgarsan fracorjim1 *)
fun hojas :: "arbol => nat" where
"hojas H = Suc 0"
| "hojas (N a b) = hojas a + hojas b"

value "hojas (N (N H H) (N H H)) = 4"

(* marpoldia1 anaprarod paupeddeg migtermor wilmorort pablucoto
ivamenjim serrodcal crigomgom rubgonmar danrodcha ferrenseg manmorjim1 juacabsou lucnovdos
dancorgar bowma *)
(* Es muy parecida a la definición anterior *)
fun hojas2 :: "arbol => nat" where
"hojas2 H = 1" |
"hojas2 (N i d) = hojas2 i + hojas2 d"

value "hojas2 (N (N H H) (N H H)) = 4"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "hojas a = hojas2 a"
by (induct a) simp_all

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

(* fraortmoy marpoldia1 anaprarod migtermor wilmorort marcarmor13 dancorgar *)
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = (if profundidad a > profundidad b
then 1 + profundidad a
else 1 + profundidad b)"

value "profundidad (N (N H H) (N H H)) = 2"

(* anaprarod wilmorort pablucoto ivamenjim serrodcal crigomgom rubgonmar
danrodcha ferrenseg josgarsan juacabsou lucnovdos bowma *)
fun profundidad2 :: "arbol => nat" where
"profundidad2 H = 0"
|"profundidad2 (N i d) = 1 + (max (profundidad2 i) (profundidad2 d))"

value "profundidad2 (N (N H H) (N H H)) = 2"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "profundidad a= profundidad2 a"
by (induct a) auto

(* paupeddeg *)
fun maximo :: "nat × nat => nat" where
"maximo (a,b) = (if a > b
then a else b)"

fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N i d) = 1 + maximo(profundidad i, profundidad d)"

(* ivamenjim: llamando a la función anterior profundidad3 *)

lemma "profundidad a = profundidad3 a"
by (induct a) auto

(* ivamenjim manmorjim1 fracorjim1 *)
fun profundidad4 :: "arbol => nat" where
"profundidad4 H = 0"
| "profundidad4 (N i d) = Suc (max (profundidad4 i)(profundidad4 d))"

lemma "profundidad a = profundidad4 a"
by (induct a) auto

text {*
---------------------------------------------------------------------
Ejercicio 5. Definir la función
abc :: "nat ⇒ arbol"
tal que (abc n) es el árbol binario completo de profundidad n. Por
ejemplo,
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))
---------------------------------------------------------------------
*}
(* fraortmoy marpoldia1 anaprarod paupeddeg migtermor wilmorort
serrodcal crigomgom rubgonmar danrodcha ferrenseg josgarsan manmorjim1 juacabsou fracorjim1 lucnovdos
dancorgar bowma *)
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = (N (abc n) (abc n))"

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

(* ivamenjim pablucoto marcarmor13*)
fun abc2 :: "nat ⇒ arbol" where
"abc2 0 = H"
| "abc2 t = N (abc2 (t-1)) (abc2 (t-1))"

value "abc2 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))"

(* ivamenjim: Metaejercicio de demostración *)
lemma "abc t = abc2 t"
by (induct t) auto

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

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

(* fraortmoy anaprarod migtermor serrodcal crigomgom rubgonmar
danrodcha ferrenseg juacabsou josgarsan fracorjim1 lucnovdos bowma *)
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc _ H = True"
| "es_abc f (N a b) = (es_abc f a ∧ es_abc f b ∧ (f a = f b))"

(* marpoldia1 paupeddeg ivamenjim pablucoto marcarmor13 manmorjim1 dancorgar *)
fun es_abc2 :: "(arbol => 'a) => arbol => bool" where
"es_abc2 f H = True" |
"es_abc2 f (N i d) = ((f i = f d) ∧ (es_abc2 f i) ∧ (es_abc2 f d))"

(* anaprarod *)
(* Equivalencia de las definiciones *)
lemma "es_abc f a = es_abc2 f a"
by (induct a) auto

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

value "size (N (N H H) (N H H)) = 3"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H))) = 7"

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

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de hojas.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal fracorjim1 josgarsan lucnovdos bowma *)

lemma abc_prof_num_hojas:
assumes "es_abc profundidad a"
shows "hojas a = 2^(profundidad a)"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom ivamenjim paupeddeg juacabsou *)
lemma AUX7: "es_abc profundidad a ⟶ (hojas a = 2^(profundidad a))"
by (induct a) simp_all

(* Otra forma de escribir lo mismo *)
(* danrodcha *)
lemma aux1: "es_abc profundidad (a::arbol) ⟹ (hojas a = 2^ (profundidad a))"
by (induct a) simp_all

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort serrodcal crigomgom
rubgonmar ivamenjim danrodcha marcarmor13 paupeddeg juacabsou bowma *)
(* También funciona con AUX7 *)

lemma lej7: "es_abc profundidad a = es_abc hojas a"
by (induct a) (auto simp add: abc_prof_num_hojas)

(* danrodcha *)
lemma 7: "es_abc profundidad a = es_abc hojas a"
apply (induct a)
apply simp
apply (auto simp add: aux1)
done

(* ferrenseg *)
lemma [simp]: "es_abc profundidad a ⟶ hojas a = 2 ^ (profundidad a)"
by (induct a) auto

theorem es_abc_profundidad_hojas: "es_abc profundidad a = es_abc hojas a"
by (induct a) auto

(* dancorgar *)
lemma rel_hojas_prof: "es_abc hojas a ∧ es_abc profundidad a
⟹ hojas a = 2 ^ profundidad a"
by (induct a) (auto)

theorem "es_abc hojas a = es_abc profundidad a"
by (induct a) (auto simp add: rel_hojas_prof)

text {*
---------------------------------------------------------------------
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del
número de hojas syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal marcarmor13 josgarsan lucnovdos bowma*)

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

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom paupeddeg juacabsou rubgonmar *)
lemma AUX8: "es_abc hojas a ⟶ (hojas a = (Suc (size a)))"
by (induct a) auto

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto serrodcal *)

lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add:abc_hojas_num_nodos [symmetric])

(* anaprarod crigomgom paupeddeg juacabsou rubgonmar *)
(* Usando AUX8 *)
lemma L8: "es_abc hojas a= es_abc size a"
by (induct a) (auto simp add: AUX8)

(* ivamenjim *)
(* Teorema auxiliar *)
lemma auxEj8: "hojas a = size a + 1"
by (induct a) auto

(* ivamenjim *)
lemma lej8: "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: auxEj8)

(* danrodcha *)
lemma aux3: "es_abc hojas a ⟹ (hojas a = 1 + size a)"
by (induct a) simp_all

(* danrodcha *)
lemma 8: "es_abc hojas a = es_abc size a"
apply (induct a)
apply simp
apply (auto simp add: aux3)
done

(* ferrenseg *)
lemma [simp]: "hojas a = size a + 1"
by (induct a) auto

theorem es_abc_hojas_size: "es_abc hojas a = es_abc size a"
by (induct a) auto

(* fracorjim1 *)

lemma aux10 : "hojas (a::arbol) = Suc(size a)"
apply (induct a)
apply auto
done

lemma es_abc_hojas_size_10 : "es_abc hojas (a::arbol) = es_abc size a"
apply (induct a)
apply (auto simp add: aux10)
done

(* dancorgar *)
lemma rel_hojas_size: "es_abc hojas a ∧ es_abc size a
⟹ hojas a = (size a) + 1"
by (induct a) (auto)

theorem "es_abc hojas a = es_abc size a"
by (induct a) (auto simp add: rel_hojas_size)

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de
la profundidad syss es completo respecto del número de nodos.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor anaprarod wilmorort pablucoto
serrodcal crigomgom rubgonmar danrodcha ivamenjim marcarmor13 paupeddeg juacabsou
josgarsan bowma lucnovdos *)

lemma lej9: "es_abc profundidad a = es_abc size a"
by (simp add: lej7 lej8)

(* ferrenseg *)

corollary es_abc_size_profundidad: "es_abc size a = es_abc profundidad a"
by (simp add: es_abc_profundidad_hojas es_abc_hojas_size)

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal crigomgom marcarmor13 paupeddeg juacabsou
dancorgar lucnovdos *)

lemma lej10: "es_abc profundidad (abc n)"
by (induct n) auto

(* anaprarod rubgonmar danrodcha ferrenseg ivamenjim paupeddeg juacabsou bowma*)
(* con un demostrador más débil *)
(* y en general para cualquier medida *)
lemma L10: "es_abc f (abc a)"
by (induct a) simp_all

(* ivamenjim *)
(* Igual que el anterior pero usando auto *)
lemma lej10: "es_abc f (abc n)"
by (induct n) auto

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es igual a
(abc (profundidad a)).
---------------------------------------------------------------------
*}

(* fraortmoy marpoldia1 migtermor wilmorort pablucoto serrodcal marcarmor13 *)

lemma lej11:
assumes " es_abc profundidad a"
shows "a = (abc (profundidad a))"
using assms
by (induct a) auto

(* Otra forma de escribir lo mismo *)
(* anaprarod crigomgom rubgonmar ferrenseg ivamenjim paupeddeg juacabsou dancorgar bowma lucnovdos *)
lemma "es_abc profundidad a ⟶ (a = (abc (profundidad a)))"
by (induct a) auto

(* danrodcha*)
lemma 11:"es_abc profundidad a ⟹ (a = (abc (profundidad a)))"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

(* migtermor *)
fun medida_nula :: "arbol => nat" where
"medida_nula H = 0"
| "medida_nula (N i d) = 0"

lemma "es_abc medida_nula a = es_abc size a"
quickcheck
oops
(* Quickcheck encuentra el siguiente contraejemplo:
a= N H (N H H)
Tras evaluar:
es_abc medida_nula a = True
es_abc size a = False*)

(* anaprarod wilmorort pablucoto serrodcal danrodcha marcarmor13 ferrenseg ivamenjim paupeddeg juacabsou rubgonmar bowma lucnovdos *)
lemma "es_abc f a = es_abc size a"
quickcheck
(* Quickcheck found a counterexample:
f = λx. a⇩1
a = N H (N H H)
Evaluated terms:
es_abc f a = True
es_abc size a = False *)
oops
(* el contraejemplo que encuentra es la medida constante a1 *)

(*crigomgom *)
(* Como en la primera de las soluciones he usado la función constante 0 pero he usado una expresión lambda*)
lemma "es_abc (λx. 0::nat) a = es_abc size a"
quickcheck
oops

(* dancorgar *)
fun medida :: "arbol => bool" where
"medida H = True"
| "medida (N i d) = ((profundidad i) = (size d))"

theorem "es_abc size a = es_abc medida a"
quickcheck
oops

end
</source>

Relación 6

2016-12-18T11:54:30Z

Jalonso: Desprotegió «Relación 6»

<source lang="isar">
chapter {* R6: Recorridos de árboles *}

theory R6_Recorridos_de_arboles
imports Main
begin

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

(* ivamenjim marpoldia1 manmorjim1 bowma migtermor wilmorort
juacabsou serrodcal pabrodmac ferrenseg rubgonmar paupeddeg
crigomgom danrodcha jeamacpov marcarmor13 josgarsan fraortmoy
dancorgar fracorjim1*)

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

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

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim marpoldia1 pablucoto bowma fraortmoy migtermor
wilmorort lucnovdos serrodcal pabrodmac jeamacpov paupeddeg
marcarmor13 josgarsan dancorgar *)

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

(* danrodcha crigomgom manmorjim1 bowma juacabsou ferrenseg
rubgonmar paupeddeg fracorjim1 *)
fun preOrden1 :: "'a arbol ⇒ 'a list" where
"preOrden1 (H x) = [x]"
| "preOrden1 (N x i d) = x # preOrden1 i @ preOrden1 d"

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

(* danrodcha *)
lemma "preOrden a = preOrden1 a"
by (induct a) simp_all

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1
pablucoto bowma fraortmoy migtermor wilmorort lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov
rubgonmar paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)

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

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

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* ivamenjim crigomgom marpoldia1 pablucoto bowma fraortmoy
migtermor wilmorort lucnovdos juacabsou serrodcal pabrodmac
ferrenseg jeamacpov rubgonmar paupeddeg marcarmor13 josgarsan
dancorgar *)
fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H t) = [t]"
| "inOrden (N t i d) = (inOrden i) @ [t] @ (inOrden d)"

(* danrodcha manmorjim1 fracorjim1 *)
fun inOrden1 :: "'a arbol ⇒ 'a list" where
"inOrden1 (H t) = [t]"
| "inOrden1 (N t i d) = inOrden1 i @ t#inOrden1 d"

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

(* manmorjim1 *)
lemma "inOrden t = inOrden1 t"
apply (induct t)
apply auto
done

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

(* ivamenjim danrodcha crigomgom marpoldia1 manmorjim1
pablucoto bowma fraortmoy migtermor wilmorort lucnovdos
juacabsou serrodcal pabrodmac ferrenseg jeamacpov rubgonmar
paupeddeg marcarmor13 josgarsan dancorgar fracorjim1 *)
fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H t) = H t"
| "espejo (N t i d) = N t (espejo d) (espejo i)"

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

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

(* ivamenjim migtermor wilmorort juacabsou serrodcal dancorgar josgarsan
*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "preOrden (espejo (N x i d)) =
preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))"
by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)"
using h1 h2 by simp
finally show "preOrden (espejo (N x i d)) = rev (postOrden (N x i d))"
by simp
qed

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

(* danrodcha crigomgom fracorjim1 *)
lemma "preOrden1 (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "preOrden1 (espejo (N x i d)) =
preOrden1 (N x (espejo d) (espejo i))"
by (simp only: espejo.simps(2))
also have "… = x#preOrden1 (espejo d) @ preOrden1 (espejo i)"
by (simp only: preOrden1.simps(2))
also have"… = x#rev (postOrden d) @ rev (postOrden i)"
using HIi HId by simp
also have "… = rev (postOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha fraortmoy *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)"
apply (induct a)
apply simp_all
done

(* pablucoto marpoldia1 jeamacpov paupeddeg marcarmor13*)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
have "preOrden (espejo (N x i d)) =
preOrden (N x (espejo d) (espejo i))" by simp
also have "... = [x] @ (preOrden (espejo d)) @ (preOrden (espejo i))"
by simp
also have "... = [x] @ rev (postOrden d) @ rev (postOrden i)"
using h1 h2 by simp
also have "... = [x] @ rev (postOrden i @ postOrden d)" by simp
also have "... = rev ( postOrden i @ postOrden d @ [x] ) " by simp
also have "... = rev (postOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* bowma *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
(* Aquí si le diga "preOrden (espejo (H t)) = rev (postOrden (H t))",
isabelle dice:
proof (prove)
goal (1 subgoal):
1. preOrden (espejo (H t)) = rev (postOrden (H t))
Introduced fixed type variable(s): 'b in "t__"
No entiendo porqué *)
next
fix t i d
assume H1: "?p i"
assume H2: "?p d"
have "preOrden (espejo (N t i d)) =
preOrden (N t (espejo d) (espejo i))" by simp
also have "... = [t] @ (preOrden (espejo d)) @ (preOrden (espejo i))"
by simp
also have "... = [t] @ rev (postOrden d) @ rev (postOrden i)"
using H1 H2 by simp
finally show "?p (N t i d)" by simp
qed

(* Comentario sobre tipo inducido. *)

(* fraortmoy lucnovdos pabrodmac*)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induct a) auto

(*pabrodmac*)
lemma
fixes a ::"'b arbol"
shows "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "preOrden (espejo (N x i d)) =
preOrden(N x (espejo d) (espejo i))" by simp
also have "… = [x]@rev(postOrden d)@rev(postOrden i)"
using h1 h2 by simp
also have "… = rev(postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "preOrden (espejo (N x l r)) =
preOrden (N x (espejo r) (espejo l))" by simp
also have "… = x # (preOrden (espejo r) @ preOrden (espejo l))" by simp
also have "… = x # (rev (postOrden r) @ rev (postOrden l))"
using H1 H2 by simp
also have "… = x # rev (postOrden l @ postOrden r)" by simp
also have "… = rev ((postOrden l) @ (postOrden r) @ [x])" by simp
also have "… = rev (postOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal
dancorgar josgarsan*)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "postOrden (espejo (N x i d)) =
postOrden (N x (espejo d) (espejo i))" by simp
also have "... = (postOrden (espejo d)) @ (postOrden (espejo i)) @ [x]"
by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x]"
using h1 h2 by simp
finally show "postOrden (espejo (N x i d)) = rev (preOrden (N x i d))"
by simp
(* "?p (N x i d)" más corto *)
qed

(* danrodcha fraortmoy *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 jeamacpov paupeddeg rubgonmar *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume H1: "?P i"
assume H2: "?P d"
have " postOrden (espejo (N x i d)) =
postOrden ( N x (espejo d) (espejo i)) " by simp
also have "... = postOrden (espejo d) @ postOrden (espejo i) @ [x]"
by simp
also have "... = rev (preOrden d) @ rev (preOrden i) @ [x] "
using H1 H2 by simp
also have "... = rev (preOrden d) @ rev (x # preOrden i)" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
also have "... = rev (preOrden (N x i d)) " by simp
finally show "?P (N x i d)" by simp
qed

(* fraortmoy lucnovdos pabrodmac paupeddeg marcarmor13 *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induct a) auto

(*pabrodmac*)
lemma
fixes a ::"'b arbol"
shows "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "postOrden (espejo (N x i d)) =
postOrden(N x (espejo d) (espejo i))" by simp
also have "… = rev (preOrden d) @ rev (preOrden i) @ [x]"
using h1 h2 by simp
also have "… = rev (preOrden (N x i d))" by simp
finally show ?thesis.
qed
qed

(* ferrenseg *)
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "postOrden (espejo (N x l r)) =
postOrden (N x (espejo r) (espejo l))" by simp
also have "… = postOrden (espejo r) @ postOrden (espejo l) @ [x]"
by simp
also have "… = rev (preOrden r) @ rev (preOrden l) @ [x]"
using H1 H2 by simp
also have "… = rev (preOrden l @ preOrden r) @ [x]" by simp
also have "… = rev ([x] @ preOrden l @ preOrden r)" by simp
also have "… = rev (preOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

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

(* ivamenjim crigomgom bowma migtermor wilmorort juacabsou serrodcal
dancorgar josgarsan *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "inOrden (espejo (N x i d)) = inOrden (N x (espejo d) (espejo i))"
by simp
also have "... = (inOrden (espejo d)) @ [x] @ (inOrden (espejo i))"
by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)"
using h1 h2 by simp
finally show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))"
by simp
qed

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) simp_all

(* danrodcha *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
show "?P (N x i d)" using HIi HId by simp
qed

(* pablucoto marpoldia1 jeamacpov paupeddeg marcarmor13*)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x) " by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "inOrden (espejo (N x i d)) =
inOrden ( N x (espejo d) (espejo i) )" by simp
also have "... = inOrden (espejo d) @ [x] @ inOrden (espejo i)"
by simp
also have "... = rev (inOrden d) @ [x] @ rev (inOrden i)"
using HI1 HI2 by simp
also have "... = rev (x # inOrden d ) @ rev (inOrden i)" by simp
also have "... = rev ( inOrden i @ x # inOrden d) " by simp
also have "... = rev (inOrden (N x i d))" by simp
finally show "?P (N x i d)" by simp
qed

(* lucnovdos pabrodmac paupeddeg fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)"
by (induct a) auto

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "inOrden (espejo (N x i d)) =
inOrden(N x (espejo d) (espejo i))" by simp
also have "… =rev(inOrden d)@[x]@rev(inOrden i)" using h1 h2 by simp
also have "… =rev(inOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* ferrenseg rubgonmar *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume H1: "?P l"
assume H2: "?P r"
show "?P (N x l r)"
proof -
have "inOrden (espejo (N x l r)) =
inOrden (N x (espejo r) (espejo l))" by simp
also have "… = inOrden (espejo r) @ [x] @ inOrden (espejo l)"
by simp
also have "… = rev (inOrden r) @ [x] @ rev (inOrden l)"
using H1 H2 by simp
also have "… = rev (inOrden l @ [x] @ inOrden r)" by simp
also have "… = rev (inOrden (N x l r))" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "inOrden (espejo (N x i d)) = rev (inOrden (N x i d))"
using h1 h2 by simp
qed

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

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto
migtermor marpoldia1 wilmorort lucnovdos juacabsou serrodcal
ferrenseg paupeddeg rubgonmar jeamacpov marcarmor13 fraortmoy
fracorjim1 josgarsan dancorgar *)
fun raiz :: "'a arbol ⇒ 'a" where
"raiz (H x) = x"
| "raiz (N x i d) = x"

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

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

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto
migtermor marpoldia1 wilmorort lucnovdos juacabsou serrodcal
pabrodmac ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy fracorjim1 josgarsan dancorgar *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x"
| "extremo_izquierda (N x i d) = extremo_izquierda i"

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

(* bowma *)
fun extremo_izquierda_1 :: "'a arbol ⇒ 'a" where
"extremo_izquierda_1 (H t) = t"
| "extremo_izquierda_1 (N t i d) = hd (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración.
Llamando teorema_13 al teorema del ejercicio 13 *)

lemma "extremo_izquierda a = extremo_izquierda_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_13)

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

(* danrodcha crigomgom manmorjim1 ivamenjim bowma pablucoto
migtermor marpoldia1 wilmorort lucnovdos juacabsou pabrodmac
serrodcal ferrenseg jeamacpov paupeddeg rubgonmar marcarmor13
fraortmoy fracorjim1 josgarsan dancorgar *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x"
| "extremo_derecha (N x i d) = extremo_derecha d"

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

(* bowma *)
fun extremo_derecha_1 :: "'a arbol ⇒ 'a" where
"extremo_derecha_1 (H t) = t"
| "extremo_derecha_1 (N t i d) = last (inOrden (N t i d))"

(* ivamenjim *)
(* Metaejercicio de demostración.
Llamando teorema_12 al teorema del ejercicio 12 *)

(*
lemma "extremo_derecha a = extremo_derecha_1 a"
by (induct a, simp_all add: aux_ej12_1 teorema_12)
*)

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

(* danrodcha *)
lemma aux_ej12: "inOrden a ≠ []"
apply (induct a)
apply simp
apply simp
done

(* danrodcha pablucoto crigomgom wilmorort juacabsou serrodcal
rubgonmar jeamacpov marcarmor13*)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HId by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* ivamenjim *)
lemma aux_ej12_1: "inOrden a ≠ []"
by (induct a) simp_all

(* ivamenjim marpoldia1 paupeddeg *)
(* Igual que la anterior, pero poniendo solo by simp en el primer have *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "last (inOrden (N x i d)) =
last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = last (inOrden d)" by (simp add: aux_ej12_1)
also have "... = extremo_derecha d" using h2 by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)"
by simp
qed

(* bowma *)
(* Casi lo mismo que el anterior,pero no hace falta suponer "?p i" *)
theorem "last (inOrden a) = extremo_derecha a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p d"
have "last (inOrden (N t i d)) = last (inOrden i @ [t] @ inOrden d)"
by simp
also have "... = last (inOrden d)" by (simp add:aux_ej12)
also have "... = extremo_derecha d" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* lucnovdos*)
(* El mismo que el anterior,pero sin usar patrones *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induct a)
fix x ::"'a"
show "last (inOrden (H x)) = extremo_derecha (H x)" by simp
next
fix x ::"'a"
fix i d ::"'a arbol"
assume HI: "last (inOrden d) = extremo_derecha d"
have "last (inOrden (N x i d)) =
last ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "… = last (inOrden d)" by (simp add: aux_ej12)
also have "… = extremo_derecha d" using HI by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show "last (inOrden (N x i d)) = extremo_derecha (N x i d)"
by simp
qed

(* migtermor *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i
fix d assume HId: "?P d"
have AUX: "¬ (inOrden d = [])" (is "?Q d")
proof (induct d)
fix hd
show "?Q (H hd)" by simp
next
fix nd
fix id assume HIid: "?Q id"
fix dd assume HIdd: "?Q dd"
show "?Q (N nd id dd)" using HIid HIdd by simp
qed
have "last (inOrden (N n i d)) = last (inOrden i @[n]@inOrden d)"
by simp
also have "… = last (inOrden d)" using AUX by simp
also have "… = extremo_derecha d" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* pabrodmac fraortmoy *)
lemma Aux_ej12: "inOrden a ≠ []"
by (induct a) auto

(* pabrodmac fraortmoy *)
theorem "last (inOrden a) = extremo_derecha a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "last (inOrden (N x i d)) = last((inOrden i)@ [x] @ (inOrden d))"
by simp
also have "… = last(inOrden d)" by (simp add: Aux_ej12)
also have "… = extremo_derecha d" using h1 h2 by simp
also have "… = extremo_derecha (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P r"
show "?P (N x l r)"
proof -
have "last (inOrden (N x l r)) =
last (inOrden r @ [x] @ inOrden r)" by simp
also have "… = last (inOrden r)" by (simp add: inOrden)
also have "… = extremo_derecha r" using HI by simp
also have "… = extremo_derecha (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
lemma
fixes a ::"'b arbol"
shows "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

(* dancorgar *)
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")
proof (induct a)
fix t
show "?P (H t)" by simp
next
fix t i d
assume H2: "?P d"
have "last (inOrden (N t i d)) = last ((inOrden i)@[t]@(inOrden d))"
by simp
also have "… = last (inOrden d)"
proof (induct d)
fix x
show "last (inOrden i @ [t] @ inOrden (H x)) = last (inOrden (H x))"
by simp
next
fix x1a d1 d2
show "last (inOrden i @ [t] @ inOrden (N x1a d1 d2)) =
last (inOrden (N x1a d1 d2))" by simp
qed
finally show "last (inOrden (N t i d)) = extremo_derecha (N t i d)"
using H2 by simp
qed

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

(* danrodcha pablucoto crigomgom juacabsou serrodcal jeamacpov
marcarmor13 *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by (simp only: inOrden.simps(2))
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HIi by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* bowma lucnovdos dancorgar *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (inOrden (N t i d)) = hd (inOrden i @ [t] @ inOrden d)"
by simp
also have "… = hd (inOrden i)" by (simp add: aux_ej12)
also have "… = extremo_izquierda i" using HI by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n d
fix i assume HId: "?P i"
have AUX: "¬ (inOrden i = [])" (is "?Q i")
proof (induct i)
fix hi
show "?Q (H hi)" by simp
next
fix ni
fix ii assume HIid: "?Q ii"
fix di assume HIdd: "?Q di"
show "?Q (N ni ii di)" using HIid HIdd by simp
qed
have "hd (inOrden (N n i d)) = hd (inOrden i @[n]@inOrden d)" by simp
also have "… = hd (inOrden i)" using AUX by simp
also have "… = extremo_izquierda i" using HId by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim marpoldia1 wilmorort paupeddeg rubgonmar *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))"
by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
also have "... = extremo_izquierda i" using h1 by simp
finally show "hd (inOrden (N x i d)) = extremo_izquierda (N x i d)"
by simp
qed

(* pabrodmac paupeddeg*)
theorem "hd (inOrden a) = extremo_izquierda a"
by (induct a)(auto simp add: Aux_ej12)

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "hd (inOrden (N x i d)) = hd((inOrden i)@ [x] @ (inOrden d))"
by simp
also have "… = hd (inOrden i)" by (simp add: Aux_ej12)
also have "… = extremo_izquierda i" using h1 h2 by simp
also have "… = extremo_izquierda (N x i d)" by simp
finally show ?thesis .
qed
qed

(* ferrenseg *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x l r
assume HI: "?P l"
show "?P (N x l r)"
proof -
have "hd (inOrden (N x l r)) =
hd (inOrden l @ [x] @ inOrden r)" by simp
also have "… = hd (inOrden l)" by (simp add: Aux_ej12)
also have "… = extremo_izquierda l" using HI by simp
also have "… = extremo_izquierda (N x l r)" by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume h1: "?P i"
assume h2: "?P d"
show "?P (N x i d)" using h1 h2 by (simp add: Aux_ej12)
qed

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

(* danrodcha pabrodmac dancorgar *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "hd (preOrden1 a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden1 (N x i d)) = hd (x#preOrden1 i @ preOrden1 d)"
by (simp only: preOrden1.simps(2))
also have "… = x" by simp
also have "… = last (postOrden i @ postOrden d @ [x])" by simp
also have "… = last (postOrden (N x i d))"
by (simp only: postOrden.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom bowma marpoldia1 wilmorort lucnovdos juacabsou
jeamacpov paupeddeg rubgonmar marcarmor13*)
(*Similar al anterior*)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)"
by simp
also have "... = x" by simp
also have "... = last ( postOrden i @ postOrden d @ [x]) " by simp
also have "... = last ( postOrden (N x i d) )" by simp
finally show "?P (N x i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
hd ([n]@preOrden i@preOrden d)" by simp
(* Si no especifico que i y d son árboles, salta un error de tipo.
Supongo que será por no haber asumido hipótesis sobre ellos *)
also have "… = last (postOrden (N n i d))" by simp
show "?P (N n i d)" by simp
qed

(* ivamenjim serrodcal *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))"
by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = last (postOrden (N x i d))"
by simp
qed

(* pabrodmac paupeddeg fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
by (induct a) auto

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = last (postOrden (N x i d))" by simp
finally show ?thesis .
qed
qed

(* Me he dado cuenta que no es necesario asumir ninguna hipótesis de
inducción puesto que no es necesario utilizarlas, así que no se si
está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x # (preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = last (postOrden l @ postOrden r @ [x])" by simp
also have "… = last (postOrden (N x l r))" by simp
also have "… = last (postOrden a)" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = last (postOrden a)"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
(* como ya se ha comentado antes, no se usan hipótesis de inducción *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
show "?P (N x i d)" by simp
qed

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

(* danrodcha *)
theorem "hd (preOrden1 a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "hd (preOrden1 (N x i d)) = hd (x#preOrden1 i @ preOrden1 d)"
by (simp only: preOrden1.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by simp
finally show "?P (N x i d)" by simp
qed

(* danrodcha pabrodmac dancorgar *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 wilmorort lucnovdos
juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: " ?P i"
assume HI2: " ?P d"
have " hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d) "
by simp
also have "... = x" by simp
also have "... = raiz (N x i d)" by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* similar al anterior pero sin suponer "?p d" *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume HI: "?p i"
have "hd (preOrden (N t i d)) = hd ([t] @ preOrden i @ preOrden d)"
by simp
also have "… = t" by simp
also have "… = last (postOrden i @ postOrden d @ [t])" by simp
also have "… = last (postOrden (N t i d))" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "hd (preOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
hd ([n]@preOrden i@preOrden d)" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)
theorem "hd (preOrden a) = raiz a"
proof (induct a)
fix x ::"'a"
show "hd (preOrden (H x)) = raiz (H x)" by simp
next
fix x ::"'a"
fix i ::"'a arbol" assume h1: "hd (preOrden i) = raiz i"
fix d ::"'a arbol" assume h2: "hd (preOrden d) = raiz d"
have "hd (preOrden (N x i d)) = hd ([x] @ (preOrden i) @ (preOrden d))"
by simp
also have "... = hd ([x])" by simp
finally show "hd (preOrden (N x i d)) = raiz (N x i d)" by simp
qed

(* pabrodmac paupeddeg fraortmoy *)
theorem "hd (preOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "hd (preOrden (N x i d) )= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(* Me he dado cuenta que no es necesario asumir ninguna hipótesis de
inducción puesto que no es necesario utilizarlas, así que no se si
está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "hd (preOrden a) = hd (preOrden (N x l r))" using H by simp
also have "… = hd (x#(preOrden l @ preOrden r))" by simp
also have "… = x" by simp
also have "… = raiz (N x l r)" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
show "?P (N x i d)" by simp
qed

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

(* crigomgom pablucoto bowma migtermor ivamenjim wilmorort lucnovdos
juacabsou pabrodmac serrodcal ferrenseg jeamacpov paupeddeg rubgonmar
marcarmor13 fraortmoy dancorgar *)
theorem "hd (inOrden a) = raiz a"
quickcheck
oops

(* danrodcha:
Auto Quickcheck found a counterexample:
a = N a1 (H a2) (H a1)
Evaluated terms:
hd (inOrden a) = a2
raiz a = a1 *)

(* ivamenjim marpoldia1 *)
theorem "hd (inOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
have "hd (inOrden (N x i d)) = hd ((inOrden i) @ [x] @ (inOrden d))" by simp
also have "... = hd (inOrden i)" by (simp add: aux_ej12_1)
(* Perdemos la x, luego se refuta el enunciado del teorema *)
oops

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

(* danrodcha pabrodmac dancorgar *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
show "?P (N x i d)" by simp
qed

(* danrodcha *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
fix x i d
assume HIi: "?P i"
assume HId: "?P d"
have "last (postOrden (N x i d)) =
last (postOrden i @ postOrden d @ [x])"
by (simp only: postOrden.simps(2))
also have "… = x" by simp
also have "… = raiz (N x i d)" by (simp only: raiz.simps(2))
finally show "?P (N x i d)" by simp
qed

(* pablucoto crigomgom ivamenjim marpoldia1 wilmorort lucnovdos
juacabsou serrodcal jeamacpov paupeddeg rubgonmar marcarmor13 *)
(* Similar al anterior *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a )
fix x
show "?P (H x)" by simp
next
fix x i d
assume HI1: "?P i"
assume HI2: "?P d"
have "last (postOrden (N x i d)) =
last ( postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
also have "... = raiz (N x i d) " by simp
finally show " ?P (N x i d)" by simp
qed

(* bowma *)
(* También sin usar el supuesto "?p d" *)
theorem "last (postOrden a) = raiz a" (is "?p a")
proof (induct a)
fix t
show "?p (H t)" by simp
next
fix t i d
assume "?p i"
(* si quito este supuesto, hay error pero no sé dónde se lo está
usando *)
have "last (postOrden (N t i d)) =
last (postOrden i @ postOrden d @ [t])" by simp
also have "... = t" by simp
also have "... = raiz (N t i d)" by simp
finally show "?p (N t i d)" by simp
qed

(* migtermor *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix h
show "?P (H h)" by simp
next
fix n i d
have "last (postOrden (N n (i :: 'a arbol) (d :: 'a arbol))) =
last (postOrden i@postOrden d@[n])" by simp
also have "… = raiz (N n i d)" by simp
finally show "?P (N n i d)" by simp
qed

(* ivamenjim: sin usar patrones *)
theorem "last (postOrden a) = raiz a"
proof (induct a)
fix x::"'a"
show "last (postOrden (H x)) = raiz (H x)" by simp
next
fix x::"'a"
fix i::"'a arbol" assume h1: "last (postOrden i) = raiz i"
fix d::"'a arbol" assume h2: "last (postOrden d) = raiz d"
have "last (postOrden (N x i d)) =
last ((postOrden i) @ (postOrden d) @ [x])" by simp
also have "... = last ([x])" by simp
finally show "last (postOrden (N x i d)) = raiz (N x i d)" by simp
qed

(* pabrodmac paupeddeg fraortmoy *)
theorem "last (postOrden a) = raiz a"
by (induct a) auto

(* pabrodmac *)
lemma
fixes a ::"'b arbol"
shows "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x
fix i assume h1: "?P i"
fix d assume h2: "?P d"
show "?P (N x i d)"
proof -
have "last (postOrden (N x i d))= x" by simp
also have "… = raiz (N x i d)" by simp
finally show ?thesis .
qed
qed

(* Me he dado cuenta que no es necesario asumir ninguna hipótesis de
inducción puesto que no es necesario utilizarlas, así que no se si
está bien hecho puesto que no se aplicaría inducción *)

(* ferrenseg *)

theorem "last (postOrden a) = raiz a" (is "?P a")
proof (cases a)
fix x
assume "a = H x"
then show "?P a" by simp
next
fix x l r
assume H: "a = N x l r"
show "?P a"
proof -
have "last (postOrden a) = last (postOrden (N x l r))" using H by simp
also have "… = last (postOrden l @ preOrden r @ [x])" by simp
also have "… = x" by simp
also have "… = raiz a" using H by simp
finally show ?thesis .
qed
qed

(* fraortmoy *)
theorem "last (postOrden a) = raiz a"
apply (induct a)
apply simp
apply simp
done

(* fraortmoy *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
show "?P (N x i d)" by simp
qed

end
</source>

Relación 7

2016-12-18T10:10:37Z

Jalonso: Página creada con '<source lang="isar"> chapter {* R7: Árboles binarios completos *} theory R7_Arboles_binarios_completos imports Main begin text {* En esta relación se piden demostracio...'

R7

2016-12-18T10:10:23Z

Jalonso: Protegió «R7» ([edit=sysop] (indefinido) [move=sysop] (indefinido))

R7

2016-12-18T10:10:15Z

Ejercicios

2016-12-18T10:09:16Z

Jalonso:

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

En esta sección se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]] y [[Relación 1 | Solución colaborativa]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]] y [[Relación 2 | Solución colaborativa]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]] y [[Relación 3 | Solución colaborativa]]).
* '''Relación 4''': Cuantificadores sobre listas. ([[R4 |Enunciado]] y [[Relación 4 | Solución colaborativa]]).
* '''Relación 5''': Eliminación de duplicados. ([[R5 |Enunciado]] y [[Relación 5 | Solución colaborativa]]).
* '''Relación 6''': Recorridos de árboles. ([[R6 |Enunciado]] y [[Relación 6 | Solución colaborativa]]).
* '''Relación 7''': Árboles binarios completos. ([[R7 |Enunciado]] y [[Relación 7 | Solución colaborativa]]).



=== Soluciones en GitHub ===

Los siguientes repositorios de GitHub también contienen soluciones de alumnos del curso: [https://github.com/MULCIA/RAIsabelleHOL serrodcal].

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

2016-12-15T12:09:09Z

Jalonso: Página creada con '<source lang="isar"> chapter {* T6b: Verificación de la ordenación por mezcla *} theory T6b_Verificacion_de_la_ordenacion_por_mezcla_sol imports Main begin text {* En esta...'

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

2016-12-15T11:57:13Z

Jalonso:

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

2016-12-15T11:56:53Z

Jalonso: Página creada con '<source language="isar"> chapter {* T6a: Verificación de la ordenación por inserción *} theory T6a_Verificacion_de_la_ordenacion_por_insercion imports Main begin text {* ...'

<source language="isar">
chapter {* T6a: Verificación de la ordenación por inserción *}

theory T6a_Verificacion_de_la_ordenacion_por_insercion
imports Main
begin

text {*
En este de tema se define el algoritmo de ordenación de listas
por inserción y se demuestra que es correcto. *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>