Razonamiento automático (2018-19) - Contribuciones del usuario [es]

Sistemas

2022-02-08T17:30:14Z

Jalonso: /* Editores de pruebas por secuentes */

Sistemas

2022-02-08T17:29:54Z

Jalonso: /* Editores de pruebas por deducción natural */

En esta página se irá escribiendo enlaces a los sistemas utilizados en el curso

== Asistentes de demostración ==
* [http://www.cl.cam.ac.uk/research/hvg/Isabelle/index.html Isabelle/HOL].

== Editores de pruebas por deducción natural ==
* [http://www.doc.ic.ac.uk/pandora/newpandora Pandora].

== Editores de pruebas por secuentes ==
* [http://www.uni-kassel.de/eecs/fachgebiete/fmv/projects/sequent-calculus-trainer.html Sequent Calculus Trainer] (un demostrador para el cálculo de secuentes).
* [http://logitext.mit.edu/main Logitext] (un demostrador interactivo basado en el cálculo de secuentes).

== Formalización ==
* [http://protosmart.uhu.es/apli2/login APLI2 (APLIcación de Ayuda Para Lógica Informática)].

Sistemas

2022-02-08T17:29:24Z

Jalonso: /* Editores de pruebas por deducción natural */

En esta página se irá escribiendo enlaces a los sistemas utilizados en el curso

== Asistentes de demostración ==
* [http://www.cl.cam.ac.uk/research/hvg/Isabelle/index.html Isabelle/HOL].

== Editores de pruebas por deducción natural ==
* [http://www.doc.ic.ac.uk/pandora/newpandora Pandora].
* [http://web.student.chalmers.se/~jespolss/Conan.html Conan] (y su [https://t.co/8aNC1H9MvD descripción])

== Editores de pruebas por secuentes ==
* [http://www.uni-kassel.de/eecs/fachgebiete/fmv/projects/sequent-calculus-trainer.html Sequent Calculus Trainer] (un demostrador para el cálculo de secuentes).
* [http://logitext.mit.edu/main Logitext] (un demostrador interactivo basado en el cálculo de secuentes).

== Formalización ==
* [http://protosmart.uhu.es/apli2/login APLI2 (APLIcación de Ayuda Para Lógica Informática)].

Documentación

2022-02-08T17:24:28Z

Jalonso:

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático". Los enlaces están actualizados en el [https://www.glc.us.es/~jalonso/RA2019/index.php/Documentaci%C3%B3n curso 2019-20].

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# J. Blanchette y J. Höltz [https://lean-forward.github.io/logical-verification/2018 Logical verification]. (Vrije Universiteit Amsterdam, 2018-19).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Trabajos-MULCIA GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Documentación

2019-10-26T13:51:59Z

Jalonso: /* Visiones generales de la DAO */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# J. Blanchette y J. Höltz [https://lean-forward.github.io/logical-verification/2018 Logical verification]. (Vrije Universiteit Amsterdam, 2018-19).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Trabajos-MULCIA GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Documentación

2019-10-26T13:48:34Z

Jalonso: /* Visiones generales de la DAO */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 Proof assistants: History, ideas and future]. ''Sadhana'', Vol. 34-1, pp. 3-25, février 2009.
# G. Gonthier [http://www.ams.org/notices/200811/tx081101382p.pdf The four-color theorem]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1382-1393, 2008.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# J. Blanchette y J. Höltz [https://lean-forward.github.io/logical-verification/2018 Logical verification]. (Vrije Universiteit Amsterdam, 2018-19).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Trabajos-MULCIA GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Ejercicios

2019-08-21T09:38:50Z

Jalonso:

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

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]]).
* '''Relación 4''': Cuantificadores sobre listas. ([[R4 |Enunciado]]).
* '''Relación 5''': Recorridos de árboles. ([[R5 |Enunciado]]).
* '''Relación 6''': Deducción natural proposicional en Isabelle/HOL. ([[R6 |Enunciado]]).
* '''Relación 7''': Deducción natural LPO en Isabelle/HOL. ([[R7 |Enunciado]]).
* '''Relación 8''': Gramáticas libres de contexto. ([[R8 |Enunciado]]).

Documentación

2019-05-31T09:43:17Z

Jalonso: /* Ofertas de trabajo */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 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.
# J. Gross [https://blogs.ams.org/mathgradblog/2017/10/15/machine-checked-proof Machine-checked proof]. ''AMS Notices'', 15 de octubre de 2017.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# J. Blanchette y J. Höltz [https://lean-forward.github.io/logical-verification/2018 Logical verification]. (Vrije Universiteit Amsterdam, 2018-19).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Trabajos-MULCIA GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Relación 8

2019-03-06T18:51:05Z

Jalonso: Protegió «Relación 8» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* R8: Gramáticas libres de contexto *}

theory R8_Gramaticas_libre_de_contexto
imports Main
begin

text {*
En esta relación se definen dos gramáticas libres de contexto y se
demuestra que son equivalentes. Además, se define por recursión una
función para reconocer las palabras de la gramática y se demuestra que
es correcta y completa. *}

text {*
---------------------------------------------------------------------
Ejercicio 1. Una gramática libre de contexto para las expresiones
parentizadas es
S ⟶ ε | '(' S ')' | SS
definir inductivamente la gramática S usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

datatype alfabeto = A | B

inductive_set S :: "alfabeto list set" where
S1: "[] ∈ S"
| S2: "w ∈ S ⟹ [A] @ w @ [B] ∈ S"
| S3: "v ∈ S ⟹ w ∈ S ⟹ v @ w ∈ S"

text {*
---------------------------------------------------------------------
Ejercicio 2. Otra gramática libre de contexto para las expresiones
parentizadas es
T ⟶ ε | T '(' T ')'
definir inductivamente la gramática T usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

inductive_set T :: "alfabeto list set" where
T1: "[] ∈ T"
| T2: "v ∈ T ⟹ w ∈ T ⟹ v @ [A] @ w @ [B] ∈ T"

text {*
---------------------------------------------------------------------
Ejercicio 3. Demostrar que T está contenido en S.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur josgomrom4 juacanrod giafus1 gleherlop *)
lemma T_en_S:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S"
proof (induction rule: T.induct)
show "[] ∈ S" by (rule S1)
next
fix v w
assume "w ∈ S"
hence "[A] @ w @ [B] ∈ S" by (rule S2)
moreover assume "v ∈ S"
ultimately show "v @ [A] @ w @ [B] ∈ S" using S3 by simp
qed
thus ?thesis using assms .
qed

(* cammonagu *)
declare S1 [iff] S2[intro!,simp]

(* cammonagu *)
declare T1 [iff]

(* cammonagu *)
lemma T2ImpS: "w ∈ T ⟹ w ∈ S"
apply (erule T.induct)
apply simp
apply (blast intro: S3)
done

(* cammonagu *)
lemma T_en_S1:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S" using assms by (rule T2ImpS)
thus ?thesis using assms .
qed

(* pabalagon marfruman1 pabbergue *)
lemma T_en_S2:
assumes "w ∈ T"
shows "w ∈ S"
using assms(1) apply (induction rule: T.induct) apply (rule S1) proof -
fix v w
assume HI1: "v ∈ S" and HI2: "w ∈ S"
have "[A] @ w @ [B] ∈ S" using HI2 by (rule S2)
thus "v @ [A] @ w @ [B] ∈ S" using HI1 S3 by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S está contenido en T.
------------------------------------------------------------------ *}

(* benber *)
lemma S_en_T:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w

have "[] ∈ T" by (rule T1)
moreover assume "w ∈ T"
ultimately have "[] @ [A] @ w @ [B] ∈ T" by (rule T2)
thus "[A] @ w @ [B] ∈ T" by simp
next
fix v w
assume "v ∈ T"
moreover assume "w ∈ T"
moreover have "⟦v ∈ T; w ∈ T⟧ ⟹ v @ w ∈ T" for v w
proof (induction "length w + length v"
arbitrary: w v
rule: less_induct)
case IH: less

show "v @ w ∈ T"
proof (cases w rule: T.cases)
show "w ∈ T" using `w ∈ T`.
next
assume "w = []"
thus "v @ w ∈ T" using `v ∈ T` by simp
next
fix w1 w2
assume "w1 ∈ T" and "w2 ∈ T"
assume "w = w1 @ [A] @ w2 @ [B]"
hence 1: "v @ w = v @ w1 @ [A] @ w2 @ [B]" by simp

have "length w1 < length w" using `w = w1 @ [A] @ w2 @ [B]`
by simp
hence "length v + length w1 < length v + length w" by simp
moreover note `v ∈ T`
moreover note `w1 ∈ T`
ultimately have "v @ w1 ∈ T" using IH by simp
moreover note `w2 ∈ T`
ultimately have "(v @ w1) @ [A] @ w2 @ [B] ∈ T" by (rule T2)
thus "v @ w ∈ T" using 1 by simp
qed
qed
ultimately show "v @ w ∈ T" by simp
qed

(* alfmarcua antramhur josgomrom4 juacanrod gleherlop *)
lemma S_en_T_2:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w
assume "w ∈ T"
have "[] @ [A] @ w @ [B] ∈ T" using T1 `w ∈ T` by (rule T2)
then show "[A] @ w @ [B] ∈ T" by (simp only: List.append.append_Nil)
next
fix w v
assume "v ∈ T"
show "w ∈ T ⟹ v @ w ∈ T"
proof (induction rule: T.induct)
show "v @ [] ∈ T" using `v ∈ T`
by (simp only: List.append.right_neutral)
next
fix va w
have "v @ va ∈ T ⟹ w ∈ T ⟹ (v @ va) @ [A] @ w @ [B] ∈ T "
by (rule T2)
then show "v @ va ∈ T ⟹ w ∈ T ⟹ v @ va @ [A] @ w @ [B] ∈ T "
by (simp only: List.append_assoc)
qed
qed

(* pabalagon giafus1 marfruman1 pabbergue *)
lemma S_en_T3:
"w ∈ S ⟹ w ∈ T"
apply (induction rule: S.induct) apply (rule T1) proof -
fix w
assume "w ∈ T"
with T1 have "[] @ [A] @ w @ [B] ∈ T" by (rule T2)
thus "[A] @ w @ [B] ∈ T" by simp
next
fix v w
assume HI1: "v ∈ T" and HI2: "w ∈ T"
show "w ∈ T ⟹ v @ w ∈ T" apply (induction rule: T.induct) apply (simp add: HI1)
proof -
fix va wa
assume "v @ va ∈ T"
moreover assume "wa ∈ T"
ultimately have "(v @ va) @ [A] @ wa @ [B] ∈ T" by (rule T2)
thus "v @ va @ [A] @ wa @ [B] ∈ T" by simp
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S y T son iguales.
------------------------------------------------------------------ *}

(* benber cammonagu antramhur josgomrom4 pabbergue *)
lemma S_igual_T:
"S = T"
using T_en_S S_en_T by auto

(* alfmarcua pabalagon giafus1 gleherlop marfruman1*)
lemma S_igual_T_2:
"S = T"
proof (rule equalityI)
show "S ⊆ T" using S_en_T by (rule subsetI)
next
show "T ⊆ S" using T_en_S by (rule subsetI)
qed

text {*
---------------------------------------------------------------------
Ejercicio 5. En lugar de una gramática, se puede usar el siguiente
procedimiento para determinar si la cadena es una sucesión de
paréntesis bien balanceada: se recorre la cadena de izquierda a
derecha contando cuántos paréntesis de necesitan para que esté bien
balanceada. Si el contador al final de la cadena es 0, la cadena está
bien balanceada.

Definir la función
balanceada :: alfabeto list ⇒ bool
tal que (balanceada w) se verifica si w está bien balanceada. Por
ejemplo,
balanceada [A,A,B,B] = True
balanceada [A,B,A,B] = True
balanceada [A,B,B,A] = False
Indicación: Definir balanceada usando la función auxiliar
balanceada_aux :: alfabeto list ⇒ nat ⇒ bool
tal que (balanceada_aux w 0) se verifica si w está bien balanceada.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur josgomrom4 pabalagon gleherlop giafus1 marfruman1 pabbergue *)
(* balanceada_aux w n = True si y solo si ([A]*n) @ w es balanceada *)
fun balanceada_aux :: "alfabeto list ⇒ nat ⇒ bool" where
"balanceada_aux [] 0 = True"
| "balanceada_aux [] (Suc n) = False"
| "balanceada_aux (B#w) 0 = False"
| "balanceada_aux (B#w) (Suc n) = balanceada_aux w n"
| "balanceada_aux (A#w) n = balanceada_aux w (Suc n)"

fun balanceada :: "alfabeto list ⇒ bool" where
"balanceada w = balanceada_aux w 0"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que balanceada es un reconocedor correcto de la
gramática S; es decir,
w ∈ S ⟹ balanceada w
------------------------------------------------------------------ *}

(* benber *)
lemma balanceada_correcto_aux1:
"balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)"
proof (induction w arbitrary: n)
case Nil
assume "balanceada_aux [] n"
thus ?case by simp
next
case IS: (Cons x w)
show ?case
proof (cases x)
case A
note `balanceada_aux (x#w) n`
hence "balanceada_aux (A#w) n" using `x = A` by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@[B]) (Suc (Suc n))" using IS.IH by simp
hence "balanceada_aux ((A#w)@[B]) (Suc n)" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@[B]) (Suc m)" using IS.IH by simp
hence "balanceada_aux (w@[B]) n" using `n = Suc m` by simp
hence "balanceada_aux (B#(w@[B])) (Suc n)" by simp
thus ?thesis using `x = B` by simp
qed
qed
qed

lemma balanceada_correcto_aux2:
assumes "balanceada v"
shows "balanceada_aux w n ⟹ balanceada_aux (w @ v) n"
proof (induction w arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux.elims by auto
thus ?case using assms by simp
next
case IS: (Cons x w)
show "balanceada_aux ((x#w)@v) n"
proof (cases x)
case A
hence "balanceada_aux (A#w) n" using IS.prems by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@v) (Suc n)" using IS.IH by simp
hence "balanceada_aux (A#(w@v)) n" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@v) m" using IS.IH by simp
hence "balanceada_aux (B#(w@v)) (Suc m)" by simp
thus ?thesis using `x = B` `n = Suc m` by simp
qed
qed
qed

lemma balanceada_correcto:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada [] = balanceada_aux [] 0" by simp
also have "..." by simp
finally show ?case.
next
case S2
fix w
assume "balanceada w"
hence "balanceada_aux w 0" by simp
hence "balanceada_aux (w@[B]) 1" using balanceada_correcto_aux1
by simp
hence "balanceada_aux ([A] @ w @ [B]) 0" by simp
thus "balanceada ([A] @ w @ [B])" by simp
next
case S3
thus ?case using balanceada_correcto_aux2 by auto
qed

(* alfmarcua antramhur josgomrom4 giafus1 pabbergue *)
lemma balanceada_correcto_aux3:
shows "balanceada_aux v m ⟹
balanceada_aux w n ⟹
balanceada_aux (v @ w) (m+n)"
proof (induction v arbitrary: n m)
case Nil
then show ?case
proof (cases m)
case 0
then have "balanceada_aux w (m + n)" using Nil.prems(2)
by (simp only:Groups.monoid_add_class.add.left_neutral)
then show ?thesis by (simp only:List.append.append_Nil)
next
case (Suc mm)
then have "False" using Nil.prems(1)
by (simp only: balanceada_aux.simps(2))
then show ?thesis ..
qed
next
case IS:(Cons a v)
show "balanceada_aux ((a # v) @ w) (m + n)"
proof (cases a)
define k :: nat where "k = m + 1"
case A
then have "balanceada_aux v k" using `k = m + 1` IS.prems(1)
by simp
then have "balanceada_aux (v @ w) (k + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (v @ w) (Suc(m + n))" using `k = m + 1`
by simp
then have "balanceada_aux (A # (v @ w)) (m + n)"
by (simp only: balanceada_aux.simps(5))
then show ?thesis using `a = A`
by (simp only:List.append.append_Cons)
next
case B
then show ?thesis
proof (cases m)
case 0
then have "False" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(3))
then show ?thesis ..
next
case (Suc mm)
hence "balanceada_aux v mm" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (v @ w) (mm + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (B # (v @ w)) (Suc (mm + n))"
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (B # (v @ w)) (m + n)"
using `m = Suc mm` by (simp only: Nat.plus_nat.add_Suc)
then show ?thesis using `a=B`
by (simp only:List.append.append_Cons)
qed
qed
qed

lemma balanceada_correcto_2:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then show ?case by (simp only: balanceada.simps)
next
case (S2 w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then have 2:"balanceada_aux (B#[]) (Suc 0)"
by (simp only: balanceada_aux.simps(4))
have "balanceada_aux w 0 ⟹
balanceada_aux [B] (Suc 0) ⟹
balanceada_aux (w @ [B]) (0+Suc 0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (w @ [B]) (Suc 0)" using 1 2
by (simp only:Groups.monoid_add_class.add.left_neutral)
then have "balanceada_aux (A # (w @ [B])) 0"
by (simp only: balanceada_aux.simps(5))
then have "balanceada_aux ([A] @ w @ [B]) 0"
by (simp only: List.append_Cons List.append_Nil)
then show ?case by (simp only: balanceada.simps)
next
case (S3 v w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have 2:"balanceada_aux v 0" using S3(3)
by (simp only: balanceada.simps)
have "balanceada_aux v 0 ⟹
balanceada_aux w 0 ⟹
balanceada_aux (v @ w) (0+0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (v @ w) 0" using 1 2
by (simp only:Groups.monoid_add_class.add.right_neutral)
then show ?case by (simp only: balanceada.simps)
qed

(* pabalagon *)
lemma balanceada_correcto_aux4:
"⟦balanceada_aux v m; balanceada_aux w n⟧ ⟹ balanceada_aux (v@w) (m+n)"
proof (induction v arbitrary: m n)
fix m n
case Nil
hence "m = 0" proof (induct m)
case 0 thus ?case by simp
next
case Suc hence False using Nil(1) by simp thus ?case by (rule FalseE)
qed
have "balanceada_aux ([] @ w) n" using Nil(2) by simp
thus "balanceada_aux ([] @ w) (m + n)" using `m=0` by simp
next
fix m n
case (Cons a v)
show "balanceada_aux ((a#v)@w) (m+n)" using Cons(2) Cons(3)
proof (cases a)
define k where "k = Suc m"
case A
hence "balanceada_aux (A#v) m" using Cons(2) by simp
hence "balanceada_aux v k" using k_def by simp
hence "balanceada_aux (v@w) (k + n)" using Cons(1,3) by simp
hence "balanceada_aux (A # (v@w)) (m+n)" using k_def by simp
thus ?thesis using A by simp
next
case B thus ?thesis proof (cases m)
case 0
hence False using Cons(2) B by simp
thus ?thesis by (rule FalseE)
next
case (Suc mm)
hence "balanceada_aux (B#v) (Suc mm)" using Cons(2) B by simp
hence "balanceada_aux v mm" by simp
hence "balanceada_aux (v@w) (mm + n)" using Cons(1, 3) by simp
hence "balanceada_aux (B#v@w) (Suc (mm+n))" by simp
thus ?thesis using B Suc by simp
qed
qed
qed

lemma balanceada_correcto3:
"w ∈ S ⟹ balanceada w"
apply (induction rule: S.induct) apply simp proof -
fix w n
assume HI: "balanceada w"
hence "balanceada_aux w 0" by simp
moreover have "balanceada_aux [B] 1" by simp
ultimately have "balanceada_aux (w@[B]) (0+1)" by (rule balanceada_correcto_aux4)
thus "balanceada ([A] @ w @ [B])" by simp
next
fix v w
assume "balanceada v"
hence 1: "balanceada_aux v 0" by simp
assume "balanceada w"
hence "balanceada_aux w 0" by simp
with 1 have "balanceada_aux (v@w) (0+0)" by (rule balanceada_correcto_aux4)
thus "balanceada (v@w)" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que balanceada es un reconocedor completo de
la gramática S; es decir,
balanceada w ⟹ w ∈ S
------------------------------------------------------------------ *}

(* benber antramhur pabalagon pabbergue *)
lemma balanceada_aux_unico:
"⟦balanceada_aux w k; balanceada_aux w l⟧ ⟹ k = l" for w k l
proof (induction w arbitrary: k l)
case Nil
hence "k = 0 ∧ l = 0" using balanceada_aux.elims by auto
thus ?case by simp
next
case IS: (Cons x w')
show ?case
proof (cases x)
case A
thus ?thesis using IS by auto
next
case B
show ?thesis
proof (cases k)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc k')
hence "balanceada_aux w' k'" using IS.prems `x = B` by simp

show ?thesis
proof (cases l)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc l')
hence "balanceada_aux w' l'" using IS.prems `x = B` by simp
thus ?thesis
using `balanceada_aux w' k'` IS.IH `k = Suc k'` `l = Suc l'`
by auto
qed
qed
qed
qed

lemma balanceada_completo_aux1:
"⟦balanceada (x # w @ [y]);
⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶ ¬ (balanceada v)⟧
⟹ x = A ∧ y = B ∧ balanceada w"
proof -
assume "balanceada (x # w @ [y])"
hence bal: "balanceada_aux ( x # w @ [y] ) 0" by simp

assume postfix_con: "⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶
¬ (balanceada v)"

have "x = A"
proof (rule ccontr)
assume "x ≠ A"
hence "x = B" using alfabeto.exhaust by blast
thus "False" using bal by simp
qed

have hl1: "balanceada_aux (w @ [y]) n ⟹ y = B" for w y n
proof (induction w arbitrary: n)
case IB: Nil
show "y = B"
proof (rule ccontr)
assume "y ≠ B"
hence "y = A" using alfabeto.exhaust by blast
thus "False" using IB by simp
qed
next
case IS: (Cons x w)
hence "balanceada_aux (x # w @ [y]) n" by simp
hence "∃m. balanceada_aux (w @ [y]) m" using balanceada_aux.elims(2)
by blast (* SH'd *)
thus "y = B" using IS.IH by auto
qed

have "y = B" using bal hl1[of "(x#w)"] by simp
hence "balanceada_aux (w @ [B]) 1" using bal `x = A` by simp

have hl2: "balanceada_aux (x#w) n ⟹ ∃m. balanceada_aux w m"
for x w n
proof (cases x)
case A
moreover assume "balanceada_aux (x#w) n"
ultimately show ?thesis by auto
next
case B
moreover assume "balanceada_aux (x#w) n"
ultimately have "balanceada_aux (B#w) n" by simp
thus ?thesis by (cases n) auto
qed

have "⟦balanceada_aux w n; u @ v = w⟧ ⟹ ∃ m. balanceada_aux v m"
for u v w n
proof (induction w arbitrary: u v n)
case Nil
hence "v = []" by simp
hence "balanceada_aux v 0" by simp
thus ?case ..
next
case IS: (Cons x w')
then obtain m where mDef: "balanceada_aux w' m" using hl2 by blast

show ?case
proof (cases u)
case Nil
hence "balanceada_aux v n" using IS by simp
thus ?thesis ..
next
case (Cons y u')
hence "w' = u' @ v" using IS.prems by simp
thus ?thesis using IS.IH mDef by simp
qed
qed
moreover have "balanceada_aux (w @ [B]) 1" using bal `x = A` `y = B`
by simp
ultimately have "u @ v = (w @ [B]) ⟹ ∃m. balanceada_aux v m"
for u v by auto
moreover {
fix u v
have 1: "⟦u' ≠ []; v ≠ []; u' @ v = (x # w @ [y])⟧ ⟹
¬(balanceada v)" for u'
using postfix_con by auto
have "⟦v ≠ []; (x#u) @ v = (x # w @ [y])⟧ ⟹ ¬(balanceada v)"
using 1[of "x#u"] by simp
hence "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹ ¬(balanceada_aux v 0)"
using `y = B` by simp
}
ultimately have hl3: "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹
∃m. balanceada_aux v (Suc m)" for u v
by (metis zero_induct) (* SH'd *)

have hl4: "⟦balanceada_aux (v @ [B]) (Suc n); ⋀s t. v = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)⟧
⟹ balanceada_aux v n" for v n
proof (induction v arbitrary: n)
case Nil
hence "balanceada_aux [B] (Suc n)" by simp
thus "balanceada_aux [] n" by simp
next
case IS: (Cons x v')

have "x#v' = [x] @ v'" by simp
then obtain m where mDef: "balanceada_aux (v' @ [B]) (Suc m)"
using IS.prems by blast
moreover have v'Postf: "⋀s t. v' = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)"
using IS.prems by auto
ultimately have "balanceada_aux v' m" using IS.IH by simp

show ?case
proof (cases x)
case A
hence "balanceada_aux ((A # v') @ [B]) (Suc n)" using IS.prems
by simp
hence "balanceada_aux (v' @ [B]) (Suc (Suc n))" by simp
hence "balanceada_aux v' (Suc n)" using IS.IH v'Postf by simp
thus ?thesis using `x = A` by simp
next
case B
hence "balanceada_aux ((B # v') @ [B]) (Suc n)" using IS.prems
by simp
hence 1: "balanceada_aux ( v' @ [B]) n" using IS.prems by simp

have "n = Suc m" using 1 mDef balanceada_aux_unico by simp
thus "balanceada_aux (x # v') n"
using `balanceada_aux v' m` `x = B` by simp
qed
qed
moreover note `balanceada_aux (w @ [B]) 1`
moreover have "w = s @ t ⟹ ∃m. balanceada_aux (t @ [B]) (Suc m)"
for s t using hl3 by simp
ultimately have "balanceada_aux w 0" by simp
thus "x = A ∧ y = B ∧ balanceada w" using `x = A` `y = B`by simp
qed

lemma balanceada_completo_aux2:
assumes "balanceada (u @ v)" and "¬ balanceada u"
shows "¬ balanceada v"
proof -
have "⟦balanceada_aux (u @ v) n; balanceada v⟧ ⟹ balanceada_aux u n"
for n
proof (induction u arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux_unico by simp
thus ?case by simp
next
case IS: (Cons x u')
show ?case
proof (cases x)
case A
hence "balanceada_aux (A # u' @ v) n" using IS.prems by simp
hence "balanceada_aux (u' @ v) (Suc n)" by simp
hence "balanceada_aux u' (Suc n)" using `balanceada v` IS.IH
by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B # u' @ v) n" using IS.prems by simp
then obtain m where "Suc m = n" by (cases n) auto
hence "balanceada_aux (B # u' @ v) (Suc m)" using 1 by simp
hence "balanceada_aux u' m" using `balanceada v` IS.IH by simp
hence "balanceada_aux (B # u') n" using `Suc m = n` by auto
thus ?thesis using `x = B` by simp
qed
qed
thus ?thesis using assms by auto
qed

lemma balanceada_completo:
assumes "balanceada w"
shows "w ∈ S"
proof -
have "balanceada w ⟹ w ∈ S"
proof (induction "length w" arbitrary: w rule: less_induct)
case IS: less

show ?case
proof (cases w)
case Nil
thus ?thesis using S1 by simp
next
case (Cons x w')
show ?thesis
proof (cases w')
case Nil
hence "¬ balanceada (x#w')" by (cases x) auto
hence "False" using `w = x # w'`IS.prems by simp
thus ?thesis ..
next
case (Cons y w'')
show ?thesis
proof cases
assume "∃u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
then obtain u v where "w = u @ v" and
"u ≠ []" and
"v ≠ []" and
"balanceada u"
and "balanceada v" by blast

have "u ∈ S" using `w = u @ v` `v ≠ []` `balanceada u` IS
by simp
moreover have "v ∈ S"
using `w = u @ v` `u ≠ []` `balanceada v` IS by simp
ultimately show "w ∈ S" using S3 `w = u @ v` by simp
next
assume "∄u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
hence 1: "⟦u @ v = w; u ≠ []; v ≠ []; balanceada u⟧ ⟹
¬ balanceada v" for u v by auto

have "w = x # y # w''" using `w = x # w'` `w' = y # w''`
by simp
moreover have "∃ u z. y # w'' = u @ [z]"
proof -
have "∃ u y. (x :: alfabeto) # v = u @ [y]" for x v
proof (induction v arbitrary: x)
case Nil
have "x # [] = [] @ [x]" by simp
thus ?case by simp
next
case IS: (Cons z v')
then obtain u' y' where "z # v' = u' @ [y']" by blast
hence "x # z # v' = x # u' @ [y']" using IS by simp
thus ?case by simp
qed
thus ?thesis by simp
qed
ultimately have "∃ u z. w = x # u @ [z]" by auto
then obtain u z where "w = x # u @ [z]" by blast
hence "balanceada (x # u @ [z])" using `balanceada w` by simp
moreover have "⟦s ≠ []; t ≠ []; s @ t = x # u @ [z]⟧ ⟹
¬ balanceada t" for s t
proof (cases "balanceada s")
case True
moreover assume "s ≠ []"
moreover assume "t ≠ []"
moreover assume "s @ t = x # u @ [z]"
ultimately show ?thesis using 1 `w = x # u @ [z]` by auto
next
case False

assume "s @ t = x # u @ [z]"
hence "x # u @ [z] = s @ t" ..
thus ?thesis
using balanceada_completo_aux2
`balanceada w`
`¬ balanceada s`
`w = x # u @ [z]`
by simp
qed
ultimately have "x = A" and "z = B" and "balanceada u"
using balanceada_completo_aux1[of x u z] by auto
moreover have "u ∈ S"
using `w = x # u @ [z]` IS `balanceada u` by simp
hence "x # u @ [z] ∈ S" using S2 `u ∈ S` `x = A` `z = B`
by simp
thus "w ∈ S" using `w = x # u @ [z]` by simp
qed
qed
qed
qed
thus ?thesis using assms .
qed

end
</source>

Relación 7

2019-03-06T18:50:45Z

Jalonso: Protegió «Relación 7» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* R7: Deducción natural de primer orden *}

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

(* benber *)
lemma
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof (rule ccontr)
assume "∄x. P a ⟶ Q x"
have "P a ⟶ (∃x. P a ⟶ Q x)"
proof
assume "P a"
with assms have "∃x. Q x" by (rule mp)
moreover have "⋀x. Q x ⟹ ∃x'. P a ⟶ Q x'"
proof -
fix x
assume "Q x"
hence "P a ⟶ Q x" by (rule impI)
thus "∃x'. P a ⟶ Q x'" by (rule exI)
qed
ultimately show "∃x. P a ⟶ Q x" by (rule exE)
qed
moreover note `∄x. P a ⟶ Q x`
ultimately have "¬(P a)" by (rule mt)
have "¬(P a) ⟶ (∃x. P a ⟶ Q x)"
proof
fix x
assume "¬(P a)"
have "P a ⟶ Q x"
proof
assume "P a"
with `¬(P a)` have "False" by (rule notE)
thus "Q x" by (rule FalseE)
qed
thus "∃x. P a ⟶ Q x" by (rule exI)
qed
moreover note `∄x. P a ⟶ Q x`
ultimately have "¬¬(P a)" by (rule mt)
moreover note `¬(P a)`
ultimately show "False" by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_52:
"p ∨ ¬p"
proof (rule ccontr)
assume 1: "¬(p ∨ ¬p)"
have 2: "¬p" proof (rule notI)
assume p hence 3: "p ∨ ¬p" by (rule disjI1)
show "False" using 1 3 by (rule notE)
qed
have 4: "p ∨ ¬p" using 2 by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed

lemma ejercicio_1:
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof (rule disjE)
show "P a ∨ ¬ P a" by (rule ejercicio_52)
next
assume "P a"
have "∃x. Q x" using assms `P a` by (rule mp)
then obtain b where "Q b" by (rule exE)
have "P a ⟹ Q b" using `P a` `Q b` by simp
have "P a ⟶ Q b" using `P a ⟹ Q b` by (rule impI)
then show "∃x. P a ⟶ Q x" by (rule exI)
next
assume "¬ P a"
fix b
have "P a ⟶ Q b"
proof (rule impI)
assume "P a"
with `¬(P a)` have "False" by (rule notE)
then show "Q b" by (rule FalseE)
qed
thus "∃x. P a ⟶ Q x" by (rule exI)
qed

(* pabalagon manperjim josgomrom4 gleherlop marfruman1 raffergon2
hugrubsan pabbergue enrparalv giafus1 antramhur *)
lemma ejercicio_1b:
assumes "P a ⟶ (∃x. Q x)"
shows "∃x. P a ⟶ Q x"
proof (rule disjE)
show "¬P a ∨ P a" by (rule excluded_middle)
next
fix b
assume 3: "¬P a"
have "P a ⟶ Q b" proof (rule impI)
assume 4: "P a" show "Q b" using 3 4 by (rule notE)
qed
thus ?thesis by (rule exI)
next
assume 1: "P a"
have "∃x. Q x" using assms(1) 1 by (rule mp)
then obtain b where 2: "Q b" by (rule exE)
have "P a ⟶ Q b" proof (rule impI)
assume "P a" show "Q b" using 2 .
qed
thus ?thesis by (rule exI)
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)
------------------------------------------------------------------ *}

(* benber *)
lemma
assumes A1: "∀x y z. R x y ∧ R y z ⟶ R x z"
and A2: "∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof -
{
fix x y
{
assume "R x y"
have "¬ (R y x)"
proof (rule ccontr)
assume "¬ ¬ (R y x)"
hence "R y x" by (rule notnotD)

note `∀x y z. R x y ∧ R y z ⟶ R x z`
moreover have "∀ y z. R x y ∧ R y z ⟶ R x z ⟹ False"
proof -
assume "∀ y z. R x y ∧ R y z ⟶ R x z"
moreover have "∀ z. R x y ∧ R y z ⟶ R x z ⟹ False"
proof -
assume "∀ z. R x y ∧ R y z ⟶ R x z"
moreover have "R x y ∧ R y x ⟶ R x x ⟹ False"
proof -
assume "R x y ∧ R y x ⟶ R x x"
moreover {
note `R x y`
moreover note `R y x`
ultimately have "R x y ∧ R y x" by (rule conjI)
}
ultimately have "R x x" by (rule mp)

note `∀x. ¬(R x x)`
moreover {
assume "¬(R x x)"
moreover note `R x x`
ultimately have "False" by (rule notE)
}
ultimately show "False" by (rule allE)
qed
ultimately show "False" by (rule allE)
qed
ultimately show "False" by (rule allE)
qed
ultimately show "False" by (rule allE)
qed
}
hence "R x y ⟶ ¬ (R y x)" by (rule impI)
}
hence "⋀x. ∀y. R x y ⟶ ¬ (R y x)" by (rule allI)
thus ?thesis by (rule allI)
qed

(* alfmarcua marfruman1 enrparalv*)
lemma ejercicio_2:
assumes "∀x y z. R x y ∧ R y z ⟶ R x z"
"∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix a
show "∀y. R a y ⟶ ¬ R y a"
proof (rule allI, rule impI)
fix b
assume "R a b"
show "¬ R b a"
proof (rule notI)
assume "R b a"
have "R a b ∧ R b a" using `R a b` `R b a` by (rule conjI)
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) by (rule allE)
then have "∀z. R a b ∧ R b z ⟶ R a z" by (rule allE)
then have "R a b ∧ R b a ⟶ R a a" by (rule allE)
then have "R a a" using `R a b ∧ R b a` by (rule mp)
have "¬ (R a a)" using assms(2) by (rule allE)
then show False using `R a a` by (rule notE)
qed
qed
qed

(* pabalagon manperjim josgomrom4 gleherlop raffergon2 hugrubsan
pabbergue giafus1 antramhur *)
lemma ejercicio_2b:
assumes "∀x y z. R x y ∧ R y z ⟶ R x z"
"∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof (rule allI)
fix a
show "∀y. R a y ⟶ ¬(R y a)"
proof (rule allI)
fix b
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) by (rule allE)
hence "∀z. R a b ∧ R b z ⟶ R a z" by (rule allE)
hence 1: "R a b ∧ R b a ⟶ R a a" by (rule allE)
have 2: "¬(R a a)" using assms(2) by (rule allE)
show "R a b ⟶ ¬(R b a)" proof (rule impI)
assume 3: "R a b"
show "¬(R b a)"
proof (rule ccontr)
assume "¬¬R b a"
hence 4: "R b a" by (rule notnotD)
have 5: "R a b ∧ R b a" using 3 4 by (rule conjI)
have 6: "R a a" using 1 5 by (rule mp)
show False using 2 6 by (rule notE)
qed
qed
qed
qed

(* pabalagon *)
lemma ejercicio_2_2:
assumes "∀x y z. R x y ∧ R y z ⟶ R x z"
"∀x. ¬(R x x)"
shows "∀x y. R x y ⟶ ¬(R y x)"
proof -
{ fix a
{ fix b
have "∀y z. R a y ∧ R y z ⟶ R a z" using assms(1) by (rule allE)
hence "∀z. R a b ∧ R b z ⟶ R a z" by (rule allE)
hence 1: "R a b ∧ R b a ⟶ R a a" by (rule allE)
have 2: "¬(R a a)" using assms(2) by (rule allE)
have "R a b ⟶ ¬(R b a)" proof (rule impI)
assume 3: "R a b"
show "¬(R b a)"
proof (rule ccontr)
assume "¬¬R b a"
hence 4: "R b a" by (rule notnotD)
have 5: "R a b ∧ R b a" using 3 4 by (rule conjI)
have 6: "R a a" using 1 5 by (rule mp)
show False using 2 6 by (rule notE)
qed
qed}
hence "∀y. R a y ⟶ ¬(R y a)" by (rule allI)}
thus "∀x y. R x y ⟶ ¬(R y x)" by (rule allI)
qed

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

(* benber pabbergue*)
(* No es cierto si el universo consiste en más que un objeto. En ese
caso, asignar la igualdad (=) a P es un contraejemplo. *)

(* alfmarcua marfruman1 raffergon2 enrparalv*)
lemma ejercicio_3:
"(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
quickcheck
oops

(* pabalagon manperjim pabbergue josgomrom4 gleherlop hugrubsan giafus1
antramhur *)
text{*
Contraejemplo en los naturales, para todo x existe y tal que x < y, pero no
existe y tal que para todo x, x < y
*}
lemma ejercicio_3: "(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
quickcheck
oops

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

(* benber *)
lemma "(∃y. ∀x. P x y) ⟶ (∀x. ∃y. P x y)"
proof
assume "∃y. ∀x. P x y"
moreover have "⋀y. ∀x. P x y ⟹ ∀x. ∃y'. P x y'"
proof
fix x y
assume "∀x'. P x' y"
hence "P x y" by (rule allE)
thus "∃y'. P x y'" by (rule exI)
qed
ultimately show "∀x. ∃y. P x y" by (rule exE)
qed

(* alfmarcua marfruman1 raffergon2 enrparalv *)
lemma ejercicio_4:
"(∃y. ∀x. P x y) ⟶ (∀x. ∃y. P x y)"
proof (rule impI, rule allI)
fix a
assume "∃y. ∀x. P x y"
then obtain b where "∀x. P x b" by (rule exE)
then have "P a b" by (rule allE)
then show "∃y. P a y" by (rule exI)
qed

(* pabalagon manperjim josgomrom4 gleherlop hugrubsan pabbergue
antramhur *)
lemma ejercicio_4_2: "(∃y. ∀x. P x y) ⟶ (∀x. ∃y. P x y)"
proof (rule impI)
assume "∃y. ∀x. P x y"
moreover have "⋀y. ∀x. P x y ⟹ ∀x. ∃y. P x y"
proof
fix x0 y0
assume "∀x. P x y0"
hence "P x0 y0" by (rule allE)
thus "∃y. P x0 y" by (rule exI)
qed
ultimately show "∀x. ∃y. P x y" by (rule exE)
qed

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

(* benber *)
lemma
assumes A1: "∀ x. P a x x"
and A2: "∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
proof
from A2
have "∀y z. P a y z ⟶ P (f a) y (f z)" 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)
moreover have "P a (f a) (f a)" using A1 by (rule allE)
ultimately show "P (f a) (f a) (f (f a))" by (rule mp)
qed

(* alfmarcua enrparalv *)
lemma ejercicio_5:
assumes "∀x. P a x x"
"∀x y z. P x y z ⟶ P (f x) y (f z)"
shows "∃z. P (f a) z (f (f a))"
proof (rule exI, rule mp)
show "P a (f a) (f a)" using assms(1) by (rule allE)
next
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) by (rule allE)
then have "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" by (rule allE)
then show "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" by (rule allE)
qed

(* pabalagon manperjim josgomrom4 gleherlop marfruman1 raffergon2
hugrubsan pabbergue giafus1 antramhur *)
lemma ejercicio_5_2:
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 (rule exI)
have "∀y z. P a y z ⟶ P (f a) y (f z)" using assms(2) ..
hence "∀z. P a (f a) z ⟶ P (f a) (f a) (f z)" ..
hence "P a (f a) (f a) ⟶ P (f a) (f a) (f (f a))" ..
moreover have "P a (f a) (f a)" using assms(1) by (rule allE)
ultimately show "P (f a) (f a) (f (f a))" by (rule mp)
qed

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

(* benber alfmarcua giafus1 *)
lemma
assumes "∀y. Q a y"
and "∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
proof
have "Q a a" using `∀y. Q a y` by (rule allE)
moreover have "Q a (s (s a))" using `∀y. Q a y` by (rule allE)
ultimately show "Q a a ∧ Q a (s (s a))" by (rule conjI)
qed

(* pabalagon manperjim josgomrom4 gleherlop marfruman1 raffergon2
hugrubsan pabbergue enrparalv antramhur *)
lemma ejercicio_6:
assumes "∀y. Q a y"
"∀x y. Q x y ⟶ Q (s x) (s y)"
shows "∃z. Q a z ∧ Q z (s (s a))"
proof (rule exI)
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)
moreover have "Q a (s a)" using assms(1) by (rule allE)
ultimately have "Q (s a) (s (s a))" by (rule mp)
with `Q a (s a)` show "Q a (s a) ∧ Q (s a) (s (s a))" by (rule conjI)
qed

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

(* benber manperjim alfmarcua pabalagon marfruman1 josgomrom4 gleherlop
raffergon2 hugrubsan pabbergue enrparalv giafus1 antramhur *)
lemma
assumes "A ∨ P ⟶ R ∧ F"
and "F ∨ N ⟶ Or"
shows "A ⟶ Or"
proof
assume "A"
hence "A ∨ P" by (rule disjI1)
with `A ∨ P ⟶ R ∧ F` have "R ∧ F" by (rule mp)
hence "F" by (rule conjunct2)
hence "F ∨ N" by (rule disjI1)
with `F ∨ N ⟶ Or` show "Or" by (rule mp)
qed

text {* ---------------------------------------------------------------
Ejercicio 8. (En APLI2 el ejercicio 5 de LP) Formalizar, y demostrar
la corrección, del siguiente argumento
En cierto experimento, cuando hemos empleado un fármaco A, el
paciente ha mejorado considerablemente en el caso, y sólo en el
caso, en que no se haya empleado también un fármaco B. Además, o se
ha empleado el fármaco A o se ha empleado el fármaco B. En
consecuencia, podemos afirmar que si no hemos empleado el fármaco
B, el paciente ha mejorado considerablemente.
Usar A: Hemos empleado el fármaco A.
B: Hemos empleado el fármaco B.
M: El paciente ha mejorado notablemente.
------------------------------------------------------------------ *}

(* benber *)
lemma
assumes "A ⟶ (M ⟷ ¬B)"
and "A ∨ B"
shows "¬B ⟶ M"
proof
assume "¬B"
note `A ∨ B`
moreover {
assume "A"
with `A ⟶ (M ⟷ ¬B)` have "M ⟷ ¬B" by (rule mp)
hence "¬B ⟹ M" by (rule iffD2)
hence "M" using `¬B` .
}
moreover {
note `¬B`
moreover assume "B"
ultimately have "M" by (rule notE)
}
ultimately show "M" by (rule disjE)
qed

(* alfmarcua marfruman1 *)
lemma ejercicio_8:
assumes "A ∧ ¬ B ⟶ M"
"A ∨ B"
shows "¬ B ⟶ M"
proof (rule impI)
assume "¬B"
show "M" using assms(2)
proof (rule disjE)
assume "A"
then have "A ∧ ¬ B" using `¬ B` by (rule conjI)
show "M" using assms(1) `A ∧ ¬ B` by (rule mp)
next
assume "B"
show "M" using `¬ B` `B` by (rule notE)
qed
qed

(* pabalagon manperjim josgomrom4 gleherlop raffergon2 hugrubsan
pabbergue enrparalv giafus1 antramhur *)
lemma ejercicio_8_2:
assumes "A ⟶ (M ⟷ ¬B)"
"A ∨ B"
shows "¬B ⟶ M"
using assms(2) proof (rule disjE)
assume 1: A
have 2: "M ⟷ ¬B" using assms(1) 1 by (rule mp)
show "¬B ⟶ M" proof (rule impI)
assume 3: "¬B" show M using 2 3 by (rule iffD2)
qed
next
assume 4: B
show ?thesis proof (rule impI)
assume "¬B" thus M using 4 by (rule notE)
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 9. (En APLI2 el ejercicio 13 de LPO) Formalizar, y decidir
la corrección, del siguiente argumento
Toda persona pobre tiene un padre rico. Por tanto, existe una
persona rica que tiene un abuelo rico.
Usar R(x) para x es rico
p(x) para el padre de x
------------------------------------------------------------------ *}

(* benber *)
lemma
assumes "∀x. ¬ R x ⟶ R (p x)"
shows "∃x. R x ∧ R (p (p x))"
proof -
have 0: "p ∨ ¬ p" for p
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
moreover {
have "p"
proof (rule ccontr)
assume "¬ p"
hence "p ∨ ¬ p" by (rule disjI2)
with `¬ (p ∨ ¬ p)` show "False" by (rule notE)
qed
hence "p ∨ ¬ p" by (rule disjI1)
}
ultimately show "False" by (rule notE)
qed

have "¬ R x ⟶ R (p x)" for x using assms(1) by (rule allE)
hence 1: "¬ R x ⟹ R (p x)" for x by (rule mp)

have 2: "⟦R y; ¬ R (p y)⟧ ⟹ ?thesis" for y
proof
assume "R y"
assume "¬ R (p y)"
hence "R (p (p y))" by (rule 1)
with `R y` show "R y ∧ R (p (p y))" by (rule conjI)
qed

have 3: "R y ⟹ ?thesis" for y
proof -
assume "R y"

have "R (p y) ∨ ¬ R (p y)" by (rule 0)
moreover {
assume "R (p y)"
have "R (p (p y)) ∨ ¬ R (p (p y))" by (rule 0)
moreover {
assume "R (p (p y))"
with `R y` have "R y ∧ R (p (p y))" by (rule conjI)
hence ?thesis by (rule exI)
}
moreover {
assume "¬ R (p (p y))"
with `R (p y)` have ?thesis by (rule 2)
}
ultimately have ?thesis by (rule disjE)
}
moreover {
assume "¬ R (p y)"
with `R y` have ?thesis by (rule 2)
}
ultimately show ?thesis by (rule disjE)
qed

fix y
have "R y ∨ ¬ R y" by (rule 0)
moreover {
assume "R y"
hence ?thesis by (rule 3)
}
moreover {
assume "¬ R y"
hence "R (p y)" by (rule 1)
hence ?thesis by (rule 3)
}
ultimately show ?thesis by (rule disjE)
qed

(* alfmarcua *)
lemma ejercicio_9_2:
assumes "∀ x. ¬ R x ⟶ R (p x)"
shows "∃x. R x ∧ R (p (p x))"
proof (rule disjE, rule ejercicio_52)
have prelemma:"(∃y. ¬ R (p y)) ⟶ ?thesis"
proof (rule impI)
assume "∃y. ¬ R (p y)"
then obtain b where "¬ R (p b)" by (rule exE)
have "¬ R (p b) ⟶ R (p (p b))" using assms by (rule allE)
then have "R (p (p b))" using `¬ R (p b)` by (rule mp)
have "¬ R b ⟶ R (p b)" using assms by (rule allE)
then have "¬¬ R b" using `¬ R (p b)` by (rule mt)
then have "R b" by (rule notnotD)
then have "R b ∧ R (p (p b))" using `R (p (p b))` by (rule conjI)
then show "∃x. R x ∧ R (p (p x))" by (rule exI)
qed

fix a
show "R (p a) ⟹ ?thesis"
proof (rule disjE, rule ejercicio_52)
assume "R (p a)"
show "R (p (p a)) ⟹ ?thesis"
proof (rule disjE, rule ejercicio_52)
assume "R (p (p (p a)))"
have "R (p a) ∧ R (p (p (p a)))" using `R (p a)` `R (p (p (p a)))` by (rule conjI)
then show ?thesis by (rule exI)
next
assume "¬ R (p (p (p a)))"
then have "∃y. ¬ R (p y)" by (rule exI)
show ?thesis using prelemma `∃y. ¬ R (p y)` by (rule mp)
qed
next
assume "¬ R (p (p a))"
then have "∃y. ¬ R (p y)" by (rule exI)
show ?thesis using prelemma `∃y. ¬ R (p y)` by (rule mp)
qed

assume "¬ R (p a)"
then have "∃y. ¬ R (p y)" by (rule exI)
show ?thesis using prelemma `∃y. ¬ R (p y)` by (rule mp)
qed

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop raffergon2
hugrubsan pabbergue enrparalv giafus1 antramhur *)
lemma ejercicio_9_3:
assumes "∀x. ¬R x ⟶ R (p x)"
shows "∃x. R x ∧ R (p (p x))"
proof -
fix y
have s1: "⟦¬R (p y)⟧ ⟹ ?thesis" for y proof (rule exI)
assume 2: "¬R (p y)"
have "¬R (p y) ⟶ R (p (p y))" using assms(1) by (rule allE)
hence 3: "R (p (p y))" using 2 by (rule mp)
have "¬R y ⟶ R (p y)" using assms(1) by (rule allE)
hence "¬¬R y" using 2 by (rule mt)
hence "R y" by (rule notnotD)
thus "R y ∧ R (p (p y))" using 3 by (rule conjI)
qed
have s2: "R y ⟹ ?thesis" for y proof -
assume 2: "R y"
have "¬R (p y) ∨ R (p y)" by (rule excluded_middle)
thus ?thesis proof (rule disjE)
assume 3: "¬R (p y)" thus ?thesis by (rule s1)
next
assume 4: "R (p y)"
have "¬R (p (p y)) ∨ R (p (p y))" by (rule excluded_middle)
thus ?thesis proof (rule disjE)
assume "¬R (p (p y))" thus ?thesis by (rule s1)
next
assume "R (p (p y))"
with `R y` have "R y ∧ R (p (p y))" by (rule conjI)
thus ?thesis by (rule exI)
qed
qed
qed
have "¬R y ∨ R y" by (rule excluded_middle)
thus ?thesis proof (rule disjE)
assume 2: "R y" thus ?thesis by (rule s2)
next
assume 4: "¬R y"
have "¬R y ⟶ R (p y)" using assms(1) by (rule allE)
hence "R (p y)" using 4 by (rule mp)
thus ?thesis by (rule s2)
qed
qed

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

(* benber *)
lemma
assumes "∀x. Af x ⟶ (∀y. E y ⟶ Ap x y)"
and "∀x. E x ⟶ ¬ Ap j x"
shows "(∃x. E x ∧ N x) ⟶ ¬ Af j"
proof
assume "∃x. E x ∧ N x"

show "¬ Af j"
proof (rule ccontr)
assume "¬ ¬ Af j"
hence "Af j" by (rule notnotD)

note `∀x. Af x ⟶ (∀y. E y ⟶ Ap x y)`
hence "Af j ⟶ (∀x. E x ⟶ Ap j x)" by (rule allE)
moreover note `Af j`
ultimately have "∀x. E x ⟶ Ap j x" by (rule mp)

note `∃x. E x ∧ N x`
moreover have "E x ∧ N x ⟹ False" for x
proof -
assume "E x ∧ N x"
hence "E x" by (rule conjunct1)

note `∀x. E x ⟶ Ap j x`
hence "E x ⟶ Ap j x" by (rule allE)
hence "Ap j x" using `E x` by (rule mp)

note `∀x. E x ⟶ ¬ Ap j x`
hence "E x ⟶ ¬ Ap j x" by (rule allE)
hence "¬ Ap j x" using `E x` by (rule mp)
thus "False" using `Ap j x` by (rule notE)
qed
ultimately show "False" by (rule exE)
qed
qed

(* alfmarcua marfruman1 *)
lemma ejercicio_10_2:
assumes "∀x y. Af x ∧ E y ⟶ Ap x y"
"∀y. E y ⟶ ¬ Ap j y"
shows "(∃y. E y ∧ N y) ⟶ ¬ Af j"
proof (rule impI)
assume "∃x. E x ∧ N x"
then obtain a where "E a ∧ N a" by (rule exE)
then have "E a" by (rule conjunct1)
show "¬ Af j"
proof (rule notI, rule notE)
assume "Af j"
then show "Af j ∧ E a" using `E a` by (rule conjI)
next
have "E a ⟶ ¬ Ap j a" using assms(2) by (rule allE)
then have "¬ Ap j a" using `E a` by (rule mp)
have "∀y. Af j ∧ E y ⟶ Ap j y" using assms(1) by (rule allE)
then have "Af j ∧ E a ⟶ Ap j a" by (rule allE)
then show "¬ (Af j ∧ E a)" using `¬ Ap j a` by (rule mt)
qed
qed

(* pabalagon manperjim josgomrom4 gleherlop raffergon2 hugrubsan
pabbergue enrparalv giafus1 antramhur *)
lemma ejercicio_10_3:
assumes "∀x y. Af x ∧ E y ⟶ Ap x y"
"∀x y. x = j ∧ E y ⟶ ¬(Ap x y)"
shows "(∃ x. (E x ∧ N x)) ⟶ ¬(Af j)"
proof (rule impI)
assume 1: "∃x. E x ∧ N x"
show "¬(Af j)" proof (rule ccontr)
fix a
assume "¬¬Af j" hence 2: "Af j" by (rule notnotD)
obtain a where 3: "E a ∧ N a" using 1 by (rule exE)
hence 4: "E a" by (rule conjunct1)
have 5: "N a" using 3 by (rule conjunct2)
have "∀y. Af j ∧ E y ⟶ Ap j y" using assms(1) by (rule allE)
hence 6: "Af j ∧ E a ⟶ Ap j a" by (rule allE)
have 7: "Af j ∧ E a" using 2 4 by (rule conjI)
have 8: "Ap j a" using 6 7 by (rule mp)
have "∀y. j = j ∧ E y ⟶ ¬(Ap j y)" using assms(2) by (rule allE)
hence 9: "j = j ∧ E a ⟶ ¬(Ap j a)" by (rule allE)
have "j = j" by (rule refl)
hence 10: "j = j ∧ E a" using 4 by (rule conjI)
have "¬(Ap j a)" using 9 10 by (rule mp)
thus False using 8 by (rule notE)
qed
qed

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

(* benber *)
lemma
assumes A1: "∀x. P x ⟶ R x"
and A2: "∀x. P x ⟶ (¬(Q x) ⟶ R x)"
and "¬(R a)"
shows "P a ⟶ Q a"
proof
have "P a ⟶ (¬(Q a) ⟶ R a)" using A2 by (rule allE)
moreover assume "P a"
ultimately have "¬(Q a) ⟶ R a" by (rule mp)

show "Q a"
proof (rule ccontr)
assume "¬(Q a)"
with `¬(Q a) ⟶ R a` have "R a" by (rule mp)
with `¬(R a)` show "False" by (rule notE)
qed
qed

(* alfmarcua *)
lemma ejercicio_11:
assumes "∄x. P x ∧ R x"
"∀x. P x ∧ (¬ Q x) ⟶ R x"
shows "P a ⟶ Q a"
proof (rule impI, rule ccontr)
assume "P a" "¬ Q a"
then have "P a ∧ (¬ Q a)" by (rule conjI)
have "P a ∧ (¬ Q a) ⟶ R a" using assms(2) by (rule allE)
then have "R a" using `P a ∧ (¬ Q a)` by (rule mp)
have "P a ∧ R a" using `P a` `R a` by (rule conjI)
then have "∃x. P x ∧ R x" by (rule exI)
show False using assms(1) `∃x. P x ∧ R x` by (rule notE)
qed

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop hugrubsan
pabbergue enrparalv giafus1 antramhur *)
lemma ejercicio_11_2:
assumes "¬(∃x. P x ∧ R x)"
"∀x. P x ∧ ¬Q x ⟶ R x"
shows "P a ⟶ Q a"
proof (rule impI)
assume 1: "P a"
show "Q a" proof (rule ccontr)
assume 2: "¬Q a"
have 3: "P a ∧ ¬Q a" using 1 2 by (rule conjI)
have 4: "P a ∧ ¬ Q a ⟶R a" using assms(2) by (rule allE)
hence 5: "R a" using 3 by (rule mp)
have 6: "P a ∧ R a" using 1 5 by (rule conjI)
hence 7: "∃x. P x ∧ R x" by (rule exI)
show False using assms(1) 7 by (rule notE)
qed
qed

end
</source>

Relación 6

2019-03-06T18:50:20Z

Jalonso: Protegió «Relación 6» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* R6: Deducción natural proposicional *}

theory R6_Deduccion_natural_proposicional
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es demostrar cada uno de los ejercicios
usando sólo las reglas básicas de deducción natural de la lógica
proposicional (sin usar el método auto).

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

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

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

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

section {* Implicaciones *}

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

(* pabalagon manperjim josgomrom4 cammonagu raffergon2 chrgencar
gleherlop giafus1 marfruman1 enrparalv pabbergue antramhur alikan
juacanrod hugrubsan aribatval*)
lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
proof -
show "q" using 1 2 by (rule mp)
qed

(* benber alfmarcua *)
lemma ejercicio_1_1:
assumes "p ⟶ q"
"p"
shows "q"
using assms by (rule mp)

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_2:
assumes 1: "p ⟶ q" and
2: "q ⟶ r" and
3: "p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed

(* benber *)
lemma ejercicio_2_1:
assumes "p ⟶ q"
"q ⟶ r"
"p"
shows "r"
proof -
have "q" using `p ⟶ q` `p` by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_3:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p ⟶ q" and
3: "p"
shows "r"
proof -
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_3_1:
assumes "p ⟶ (q ⟶ r)"
"p ⟶ q"
"p"
shows "r"
proof -
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu chrgencar raffergon2
gleherlop giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_4:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof -
{ assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "r" using 2 4 by (rule mp)}
thus "p ⟶ r" by (rule impI)
qed

(* benber *)
lemma ejercicio_4_1:
assumes "p ⟶ q"
"q ⟶ r"
shows "p ⟶ r"
proof
assume p
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim raffergon2 giafus1 gleherlop marfruman1 alfmarcua
enrparalv chrgencar pabbergue antramhur alikan hugrubsan aribatval*)
lemma ejercicio_5:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
show "r" using 4 2 by (rule mp)
qed
qed

(* benber josgomrom4 juacanrod cammonagu *)
lemma ejercicio_5_1:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof
assume "q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
thus "r" using `q` by (rule mp)
qed
qed

(* pabalagon *)
lemma ejercicio_5_2:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{ assume 2: "q"
{ assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "r" using 4 2 by (rule mp)}
hence "p ⟶ r" by (rule impI)
}
thus "q ⟶ (p ⟶ r)" by (rule impI)
qed

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

(* pabalagon manperjim cammonagu chrgencar raffergon2 gleherlop giafus1
marfruman1 alfmarcua enrparalv pabbergue antramhur alikan juacanrod
hugrubsan aribatval*)
lemma ejercicio_6:
assumes 1: "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed

(* benber josgomrom4 *)
lemma ejercicio_6_1:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ⟶ q` `p` have "q" by (rule mp)
ultimately show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 gleherlop
marfruman1 enrparalv pabbergue antramhur alikan hugrubsan aribatval*)
lemma ejercicio_7:
assumes 1: "p"
shows "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed

(* benber cammonagu juacanrod chrgencar *)
lemma ejercicio_7_1:
assumes "p"
shows "q ⟶ p"
proof
show "p" using `p` .
qed

(* alfmarcua *)
lemma ejercicio_7_2:
assumes "p"
shows "q ⟶ p"
using assms by (rule impI)

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 marfruman1
enrparalv pabbergue antramhur alikan hugrubsan aribatval*)
lemma ejercicio_8:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed
qed

(* benber cammonagu gleherlop chrgencar juacanrod alfmarcua *)
lemma ejercicio_8_1:
"p ⟶ (q ⟶ p)"
using ejercicio_7_1 by (rule impI)

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

(* pabalagon manperjim raffergon2 giafus1 marfruman1 alfmarcua enrparalv
gleherlop antramhur alikan hugrubsan aribatval*)
lemma ejercicio_9:
assumes 1: "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q ⟶ r"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu chrgencar juacanrod pabbergue *)
lemma ejercicio_9_1:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof
assume "q ⟶ r"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop alfmarcua
enrparalv pabbergue antramhur alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_10:
assumes 1: "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof (rule impI)
assume 2: "r"
show "q ⟶ (p ⟶ s)"
proof (rule impI)
assume 3: "q"
show "p ⟶ s"
proof (rule impI)
assume 4: "p"
have 5: "q ⟶ (r ⟶ s)" using 1 4 by (rule mp)
have 6: "r ⟶ s" using 5 3 by (rule mp)
show "s" using 6 2 by (rule mp)
qed
qed
qed

(* benber josgomrom4 cammonagu chrgencar giafus1 *)
lemma ejercicio_10_1:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof
assume "r"
show "q ⟶ (p ⟶ s)"
proof
assume "q"
show "p ⟶ s"
proof
assume "p"
with `p ⟶ (q ⟶ (r ⟶ s))`
have "q ⟶ (r ⟶ s)" by (rule mp)
hence "r ⟶ s" using `q` by (rule mp)
thus "s" using `r` by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim josgomrom4 gleherlop cammonagu giafus1 alfmarcua
chrgencar pabbergue alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_11:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)" using 1 ejercicio_6 by simp
qed

(* pabalagon raffergon2 marfruman1 enrparalv antramhur *)
lemma ejercicio_11_2:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed
qed

(* benber *)
lemma ejercicio_11_1:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume p
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show r by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop enrparalv
pabbergue antramhur alikan juacanrod hugrubsan aribatval*)
lemma ejercicio_12:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ⟶ q"
proof (rule impI)
assume 5: "p"
show "q" using 3 by this
qed
show "r" using 1 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu giafus1 alfmarcua chrgencar *)
lemma ejercicio_12_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed
qed

section {* Conjunciones *}

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

(* pabalagon *)
lemma ejercicio_13:
assumes "p"
"q"
shows "p ∧ q"
using assms(1, 2) by (rule conjI)

(* benber manperjim josgomrom4 cammonagu raffergon2 marfruman1 alfmarcua
enrparalv chrgencar gleherlop pabbergue antramhur juacanrod hugrubsan
alikan aribatval*)
lemma ejercicio_13_1:
assumes "p"
"q"
shows "p ∧ q"
using assms by (rule conjI)

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

(* pabalagon josgomrom4 *)
lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
using assms(1) by (rule conjunct1)

(* benber manperjim cammonagu raffergon2 marfruman1 alfmarcua enrparalv
chrgencar pabbergue gleherlop antramhur hugrubsan juacanrod alikan *)
lemma ejercicio_14_1:
assumes "p ∧ q"
shows "p"
using assms by (rule conjunct1)

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

(* pabalagon manperjim juacanrod josgomrom4 *)
lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
using assms(1) by (rule conjunct2)

(* benber cammonagu raffergon2 marfruman1 alfmarcua enrparalv chrgencar
pabbergue antramhur gleherlop hugrubsan alikan aribatval*)
lemma ejercicio_15_1:
assumes "p ∧ q"
shows "q"
using assms by (rule conjunct2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammmonagu enrparalv chrgencar gleherlop pabbergue antramhur
hugrubsan alikan juacanrod cammonagu aribatval*)
lemma ejercicio_16:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof -
have 1: "p" using assms(1) by (rule conjunct1)
have 2: "q ∧ r" using assms(1) by (rule conjunct2)
have 3: "q" using 2 by (rule conjunct1)
have 4: "r" using 2 by (rule conjunct2)
have 5: "p ∧ q" using 1 3 by (rule conjI)
show "(p ∧ q) ∧ r" using 5 4 by (rule conjI)
qed

(* benber *)
lemma ejercicio_16_1:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof - (* TODO? *)
have "q ∧ r" using assms by (rule conjunct2)
have "p" using assms by (rule conjunct1)
moreover have "q" using `q ∧ r` by (rule conjunct1)
ultimately have "p ∧ q" by (rule conjI)
moreover have "r" using `q ∧ r` by (rule conjunct2)
ultimately show "(p ∧ q) ∧ r" by (rule conjI)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv hugrubsan
juacanrod alikan aribatval*)
lemma ejercicio_17:
assumes 1: "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have 2: "r" using 1 by (rule conjunct2)
have 3: "p ∧ q" using 1 by (rule conjunct1)
have 4: "p" using 3 by (rule conjunct1)
have 5: "q" using 3 by (rule conjunct2)
have 6: "q ∧ r" using 5 2 by (rule conjI)
show ?thesis using 4 6 by (rule conjI)
qed

(* benber *)
lemma ejercicio_17_1:
assumes "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have "p ∧ q" using assms by (rule conjunct1)
have "p" using `p ∧ q` by (rule conjunct1)
moreover have "q ∧ r"
proof (rule conjI)
show "q" using `p ∧ q` by (rule conjunct2)
next
show "r" using assms by (rule conjunct2)
qed
ultimately show ?thesis by (rule conjI)
qed

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

(* pabalagon raffergon2 marfruman1 juacanrod alikan *)
lemma ejercicio_18:
assumes "p ∧ q"
shows "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using assms(1) by (rule conjunct2)
qed

(* benber manperjim josgomrom4 cammonagu alfmarcua chrgencar pabbergue
gleherlop antramhur enrparalv hugrubsan aribatval*)
lemma ejercicio_18_1:
assumes "p ∧ q"
shows "p ⟶ q"
proof
show "q" using assms by (rule conjunct2)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_19:
assumes 1: "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof (rule impI)
assume 2: "p"
have 3: "p ⟶ q" using 1 by (rule conjunct1)
have 4: "p ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 3 2 by (rule mp)
have 6: "r" using 4 2 by (rule mp)
show "q ∧ r" using 5 6 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_19_1:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume p
show "q ∧ r"
proof
have "p ⟶ q" using assms by (rule conjunct1)
thus "q" using `p` by (rule mp)
next
have "p ⟶ r" using assms by (rule conjunct2)
thus "r" using `p` by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_20:
assumes 1: "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof (rule conjI)
show "p ⟶ q"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "q" using 3 by (rule conjunct1)
qed
show "p ⟶ r"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "r" using 3 by (rule conjunct2)
qed
qed

(* benber *)
lemma ejercicio_20_1:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
show "p ⟶ q"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "q" by (rule conjunct1)
qed
next
show "p ⟶ r"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "r" by (rule conjunct2)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar pabbergue gleherlop antramhur enrparalv juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_21:
assumes 1: "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p" using 2 by (rule conjunct1)
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 by (rule conjunct2)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_21_1:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ∧ q` have "q" by (rule conjunct2)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan aribatval*)
lemma ejercicio_22:
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_22_1:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
with `p` have "p ∧ q" by (rule conjI)
with `p ∧ q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan aribatval*)
lemma ejercicio_23:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using 2 by (rule conjunct2)
qed
show "r" using 1 3 by (rule mp)
qed

(* benber cammonagu *)
lemma ejercicio_23_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "q" by (rule conjunct2)
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv hugrubsan juacanrod
cammonagu alikan aribatval*)
lemma ejercicio_24:
assumes 1: "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof (rule impI)
assume 2: "p ⟶ q"
have 3: "p" using 1 by (rule conjunct1)
have 4: "q ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 2 3 by (rule mp)
show 6: "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_24_1:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
have "q ⟶ r" using assms by (rule conjunct2)
assume "p ⟶ q"
moreover have "p" using assms by (rule conjunct1)
ultimately have "q" by (rule mp)
with `q ⟶ r` show r by (rule mp)
qed

section {* Disyunciones *}

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

(* pabalagon manperjim josgomrom4 benber cammonagu raffergon2 marfruman1
alfmarcua chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim josgomrom4 benber cammonagu marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan aribatval*)
lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
using assms(1) by (rule disjI2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
pabbergue antramhur enrparalv juacanrod hugrubsan cammonagu alikan aribatval*)
lemma ejercicio_27:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1 proof (rule disjE)
assume 2: "p" thus "q ∨ p" by (rule disjI2)
next
assume 3: "q" thus "q ∨ p" by (rule disjI1)
qed

(* benber alfmarcua gleherlop *)
lemma ejercicio_27_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms .
moreover have "p ⟹ q ∨ p" by (rule disjI2)
moreover have "q ⟹ q ∨ p" by (rule disjI1)
ultimately show "q ∨ p" by (rule disjE)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
gleherlop alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan
cammonagu alikan aribatval*)
lemma ejercicio_28:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q" show "p ∨ r" using 2
proof (rule disjE)
assume 3: p thus "p ∨ r" by (rule disjI1)
next
assume 4: q have r using 1 4 by (rule mp)
thus "p ∨ r" by (rule disjI2)
qed
qed

(* benber *)
lemma ejercicio_28_1:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
moreover have "p ⟹ p ∨ r" by (rule disjI1)
moreover have "q ⟹ p ∨ r"
proof (rule disjI2)
assume "q"
with `q ⟶ r` show "r" by (rule mp)
qed
ultimately show "p ∨ r" by (rule disjE)
qed

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

(* pabalagon juacanrod marfruman1 *)
lemma ejercicio_29:
assumes 1: "p ∨ p"
shows "p"
using 1 proof (rule disjE)
assume "p" thus "p" .
next
assume "p" thus "p" .
qed

(* benber manperjim cammonagu josgomrom4 raffergon2 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv hugrubsan alikan aribatval*)
lemma ejercicio_29_1:
assumes "p ∨ p"
shows "p"
using assms by (rule disjE)

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

(* pabalagon manperjim benber josgomrom4 raffergon2 marfruman1
chrgencar alfmarcua pabbergue gleherlop antramhur enrparalv hugrubsan
juacanrod cammonagu alikan aribatval*)
lemma ejercicio_30:
assumes "p"
shows "p ∨ p"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_31:
assumes 1: "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r" (is "?R")
using 1 proof (rule disjE)
assume "p" hence "p ∨ q" by (rule disjI1)
thus ?R by (rule disjI1)
next
assume "q ∨ r" thus ?R
proof (rule disjE)
assume "q" hence "p ∨ q" by (rule disjI2)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "r" thus ?thesis by (rule disjI2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_31_1:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
proof -
have "p ∨ (q ∨ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "q ∨ r"
moreover {
assume "q"
hence "p ∨ q" by (rule disjI2)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "r"
hence "(p ∨ q) ∨ r" by (rule disjI2)
}
ultimately have "(p ∨ q) ∨ r" by (rule disjE)
}
ultimately show "(p ∨ q) ∨ r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_32:
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1 proof (rule disjE)
assume "p ∨ q" thus ?thesis
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume q hence "q ∨ r" by (rule disjI1)
thus ?thesis by (rule disjI2)
qed
next
assume r hence "q ∨ r" by (rule disjI2)
thus ?thesis by (rule disjI2)
qed

(* benber cammonagu *)
lemma ejercicio_32_1:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
proof -
have "(p ∨ q) ∨ r" using assms .
moreover {
assume "p ∨ q"
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
hence "q ∨ r" by (rule disjI1)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
moreover {
assume "r"
hence "q ∨ r" by (rule disjI2)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar gleherlop
alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_33:
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: p using 1 by (rule conjunct1)
show ?thesis
proof (rule disjE)
assume 3: q have "p ∧ q" using 2 3 by (rule conjI)
thus ?thesis by (rule disjI1)
next
assume 4: r have "p ∧ r" using 2 4 by (rule conjI)
thus ?thesis by (rule disjI2)
next
show "q ∨ r" using 1 by (rule conjunct2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_33_1:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have "p" using assms by (rule conjunct1)
have "q ∨ r" using assms by (rule conjunct2)
moreover {
assume "q"
with `p` have "p ∧ q" by (rule conjI)
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `p` have "p ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_34:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms(1) proof (rule disjE)
assume 2: "p ∧ q" hence q by (rule conjunct2)
hence 3: "q ∨ r" by (rule disjI1)
have p using 2 by (rule conjunct1)
thus ?thesis using 3 by (rule conjI)
next
assume 4: "p ∧ r" hence r by (rule conjunct2)
hence 5: "q ∨ r" by (rule disjI2)
have p using 4 by (rule conjunct1)
thus ?thesis using 5 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_34_1:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
proof -
have "(p ∧ q) ∨ (p ∧ r)" using assms .
moreover {
assume "p ∧ q"
hence "p" by (rule conjunct1)
moreover {
have "q" using `p ∧ q` by (rule conjunct2)
hence "q ∨ r" by (rule disjI1)
}
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "p ∧ r"
hence "p" by (rule conjunct1)
moreover {
have "r" using `p ∧ r` by (rule conjunct2)
hence "q ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
using assms(1) proof (rule disjE)
assume 1: p hence 2: "p ∨ r" by (rule disjI1)
have "p ∨ q" using 1 by (rule disjI1)
thus ?thesis using 2 by (rule conjI)
next
assume 3: "q ∧ r" hence r by (rule conjunct2)
hence 4: "p ∨ r" by (rule disjI2)
have q using 3 by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
thus ?thesis using 4 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_35_1:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
proof -
have "p ∨ (q ∧ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
moreover have "p ∨ r" using `p` by (rule disjI1)
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "q ∧ r"
{
have "q" using `q ∧ r` by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
}
moreover {
have "r" using `q ∧ r` by (rule conjunct2)
hence "p ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_36:
assumes 1: "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have 2: "p ∨ q" using 1 by (rule conjunct1)
have 3: "p ∨ r" using 1 by (rule conjunct2)
show ?thesis using 2
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 4: q show ?thesis using 3
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 5: r have "q ∧ r" using 4 5 by (rule conjI)
thus ?thesis by (rule disjI2)
qed
qed
qed

(* benber cammonagu *)
lemma ejercicio_36_1:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have "p ∨ q" using assms by (rule conjunct1)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
have "p ∨ r" using assms by (rule conjunct2)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `q` have "q ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_37:
assumes 1: "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof (rule impI)
have 2: "p ⟶ r" using 1 by (rule conjunct1)
have 3: "q ⟶ r" using 1 by (rule conjunct2)
assume 4: "p ∨ q" show "r" using 4
proof (rule disjE)
assume 5: "p" show "r" using 2 5 by (rule mp)
next
assume 6: "q" show "r" using 3 6 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_37_1:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume "p ∨ q"
moreover {
have "p ⟶ r" using assms by (rule conjunct1)
moreover assume "p"
ultimately have "r" by (rule mp)
}
moreover {
have "q ⟶ r" using assms by (rule conjunct2)
moreover assume "q"
ultimately have "r" by (rule mp)
}
ultimately show "r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_38:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof (rule conjI)
show "p ⟶ r"
proof (rule impI)
assume "p" hence 1: "p ∨ q" by (rule disjI1)
show "r" using assms(1) 1 by (rule mp)
qed
next
show "q ⟶ r"
proof (rule impI)
assume q hence 2: "p ∨ q" by (rule disjI2)
show r using assms(1) 2 by (rule mp)
qed
qed

(* benber cammonagu*)
lemma ejercicio_38_1:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
show "p ⟶ r"
proof
assume "p"
hence "p ∨ q" by (rule disjI1)
with assms show "r" by (rule mp)
qed
next
show "q ⟶ r"
proof
assume "q"
hence "p ∨ q" by (rule disjI2)
with assms show "r" by (rule mp)
qed
qed

section {* Negaciones *}

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

(* pabalagon manperjim benber josgomrom4 raffergon2 gleherlop
marfruman1 chrgencar alfmarcua pabbergue enrparalv juacanrod
hugrubsan cammonagu alikan aribatval*)
lemma ejercicio_39:
assumes "p"
shows "¬¬p"
using assms(1) by (rule notnotI)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop juacanrod enrparalv hugrubsan alikan chrgencar aribatval*)
lemma ejercicio_40:
assumes 1: "¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: p show q using 1 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_40_1:
assumes "¬p"
shows "p ⟶ q"
proof
assume "p"
with `¬p` show "q" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan chrgencar aribatval*)
lemma ejercicio_41:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 2: "¬q" show "¬p" using 1 2 by (rule mt)
qed

(* benber cammonagu *)
lemma ejercicio_41_1:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with `p ⟶ q` show "¬p" by (rule mt)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan chrgencar alikan aribatval*)
lemma ejercicio_42:
assumes "p∨q"
"¬q"
shows "p"
using assms(1) proof (rule disjE)
assume "p" thus "p" .
next
assume 2: "q" show "p" using assms(2) 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_42_1:
assumes "p∨q"
"¬q"
shows "p"
proof -
note `p ∨ q`
moreover have "p ⟹ p" .
moreover {
assume "q"
with `¬q` have "p" by (rule notE)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop chrgencar enrparalv juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_43:
assumes "p ∨ q"
"¬p"
shows "q"
using assms(1) proof (rule disjE)
assume 1: "p" show "q" using assms(2) 1 by (rule notE)
next
assume "q" thus "q" .
qed

(* benber cammonagu*)
lemma ejercicio_43_1:
assumes "p ∨ q"
"¬p"
shows "q"
proof -
note `p ∨ q`
moreover {
assume "p"
with `¬p` have "q" by (rule notE)
}
moreover have "q ⟹ q" .
ultimately show "q" by (rule disjE)
qed

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

(* pabalagon manperjim gleherlop chrgencar josgomrom4 marfruman1 pabbergue
juacanrod hugrubsan alikan aribatval*)
lemma ejercicio_44:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof (rule notI)
assume 1: "¬p ∧ ¬q" hence 2: "¬p" by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
show "False"
using assms(1) proof (rule disjE)
assume 4: "p" show ?thesis using 2 4 by (rule notE)
next
assume 5: "q" show ?thesis using 3 5 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_44_1:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof
assume "¬p ∧ ¬q"
note `p ∨ q`
moreover {
from `¬p ∧ ¬q` have "¬p" by (rule conjunct1)
moreover assume "p"
ultimately have "False" by (rule notE)
}
moreover {
from `¬p ∧ ¬q` have "¬q" by (rule conjunct2)
moreover assume "q"
ultimately have "False" by (rule notE)
}
ultimately show "False" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan chrgencar aribatval*)
lemma ejercicio_45:
assumes 1: "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof (rule notI)
assume 2: "¬p ∨ ¬q" have 3: "p" using 1 by (rule conjunct1)
have 4: "q" using 1 by (rule conjunct2)
show "False" using 2
proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_45_1:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
moreover {
assume "¬p"
moreover have "p" using `p ∧ q` by (rule conjunct1)
ultimately have "False" by (rule notE)
}
moreover {
assume "¬q"
moreover have "q" using `p ∧ q` by (rule conjunct2)
ultimately have "False" by (rule notE)
}
ultimately show False by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan chrgencar aribatval*)
lemma ejercicio_46:
assumes 1: "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
show "¬p"
proof (rule notI)
assume p hence 2: "p ∨ q" by (rule disjI1)
show False using 1 2 by (rule notE)
qed
show "¬q"
proof (rule notI)
assume q hence 3: "p ∨ q" by (rule disjI2)
show False using 1 3 by (rule notE)
qed
qed

(* benber cammmonagu *)
lemma ejercicio_46_1:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof (rule ccontr)
assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1)
with assms show "False" by (rule notE)
qed
next
show "¬q"
proof (rule ccontr)
assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2)
with assms show "False" by (rule notE)
qed
qed

(* alfmarcua *)
lemma ejercicio_46_2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
have "p ⟹ p ∨ q" by (rule disjI1)
then have "p ⟶ p ∨ q" by (rule impI)
then show "¬ p" using assms by (rule mt)
next
have "q ⟹ p ∨ q" by (rule disjI2)
then have "q ⟶ p ∨ q" by (rule impI)
then show "¬ q" using assms by (rule mt)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbregue juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_47:
assumes 1: "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have 2: "¬p" using 1 by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
assume 4: "p ∨ q"
show False
using 4 proof (rule disjE)
assume 5: p show ?thesis using 2 5 by (rule notE)
next
assume 6: q show ?thesis using 3 6 by (rule notE)
qed
qed

(* benber gleherlop chrgencar cammonagu*)
lemma ejercicio_47_1:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
hence "¬(¬p ∧ ¬q)" by (rule ejercicio_44_1)
thus "False" using assms by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_47_2:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have "¬ p" using assms by (rule conjunct1)
have "¬ q" using assms by (rule conjunct2)
assume "p ∨ q"
then have "q" using `¬ p` by (rule ejercicio_43)
show False using `¬ q` `q` by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbergue juacanrod
hugrubsan alikan aribatval*)
lemma ejercicio_48:
assumes 1: "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof (rule notI)
assume 2: "p ∧ q" hence 3: p by (rule conjunct1)
have 4: q using 2 by (rule conjunct2)
show False
using 1 proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua gleherlop chrgencar cammonagu *)
lemma ejercicio_48_1:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "¬(¬p ∨ ¬q)" by (rule ejercicio_45_1)
thus "False" using assms by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcu gleherlop
hugrubsan juacanrod cammonagu alikan chrgencar aribatval*)
lemma ejercicio_49:
"¬(p ∧ ¬p)"
proof (rule notI)
assume 1: "p ∧ ¬p" hence 2: p by (rule conjunct1)
have "¬p" using 1 by (rule conjunct2)
thus "False" using 2 by (rule notE)
qed

(* benber *)
lemma ejercicio_49_1:
"¬(p ∧ ¬p)"
proof
assume "p ∧ ¬p"
hence "¬p" by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "False" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan alikan chrgencar aribatval*)
lemma ejercicio_50:
assumes 1: "p ∧ ¬p"
shows "q"
proof (rule notE)
show p using 1 by (rule conjunct1)
show "¬p" using 1 by (rule conjunct2)
qed

(* benber cammonagu*)
lemma ejercicio_50_1:
assumes "p ∧ ¬p"
shows "q"
proof -
have "¬p" using `p ∧ ¬p` by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "q" by (rule notE)
qed

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

(* pabalagon manperjim benber raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan cammmonagu alikan
chrgencar aribatval*)
lemma ejercicio_51:
assumes "¬¬p"
shows "p"
using assms(1) by (rule notnotD)

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

(* pabalagon manperjim marfruman1 josgomrom4 juacanrod pabbergue alikan aribatval*)
lemma ejercicio_52:
"p ∨ ¬p"
proof (rule ccontr)
assume 1: "¬(p ∨ ¬p)"
have 2: "¬p" proof (rule notI)
assume p hence 3: "p ∨ ¬p" by (rule disjI1)
show "False" using 1 3 by (rule notE)
qed
have 4: "p ∨ ¬p" using 2 by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_52_1:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
hence "¬p ∧ ¬¬p" by (rule ejercicio_46_1)
hence "¬p" by (rule conjunct1)
moreover {
have "¬¬p" using `¬p ∧ ¬¬p` by (rule conjunct2)
hence "p" by (rule notnotD)
}
ultimately show "False" by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_52_2:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
then have "¬ p ∧ ¬¬ p" by (rule ejercicio_46)
then show False by (rule ejercicio_50)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
juacanrod pabbergue alikan chrgencar aribatval*)
lemma ejercicio_53:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume 1: "(p ⟶ q) ⟶ p"
show p proof (rule ccontr)
assume 2: "¬p"
have 3: "¬(p ⟶ q)" using 1 2 by (rule mt)
have 4: "p ⟶ q" proof (rule impI)
assume 5: p show q using 2 5 by (rule notE)
qed
show False using 3 4 by (rule notE)
qed
qed

(* benber cammonagu *)
lemma ejercicio_53_1:
"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume "(p ⟶ q) ⟶ p"
have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover have "p ⟹ p" .
moreover {
assume "¬ p"
hence "p ⟶ q" by (rule ejercicio_40_1)
with `(p ⟶ q) ⟶ p` have "p" by (rule mp)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue chrgencar alikan aribatval*)
lemma ejercicio_54:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p" hence 3: "¬¬p" by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt)
thus "q" by (rule notnotD)
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_54_1:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

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

(* pabalagon marfruman1*)
lemma ejercicio_55:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume 2: "¬(p ∨ q)"
have 3: "p"
proof (rule ccontr)
assume 4: "¬p"
have 5: "q"
proof (rule ccontr)
assume 6: "¬q" have 7: "¬p ∧ ¬q" using 4 6 by (rule conjI)
show False using 1 7 by (rule notE)
qed
have 8: "p ∨ q" using 5 by (rule disjI2)
show False using 2 8 by (rule notE)
qed
have 9: "p ∨ q" using 3 by (rule disjI1)
show False using 2 9 by (rule notE)
qed

(* benber alfmarcua josgomrom4 manperjim pabbergue juacanrod cammonagu chrgencar alikan aribatval*)
lemma ejercicio_55_1:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume "¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule ejercicio_46_1)
with assms show False by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue chrgencar alikan aribatval*)
lemma ejercicio_56:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
show 3: p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 1 4 by (rule notE)
qed
show 5: q
proof (rule ccontr)
assume "¬q" hence 6: "¬p ∨ ¬q" by (rule disjI2)
show False using 1 6 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_56_1:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule ejercicio_46_1)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
moreover {
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
}
ultimately show "p ∧ q" by (rule conjI)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar gleherlop
juacanroz pabbergue alikan *)
lemma ejercicio_57:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume 2: "¬(¬p ∨ ¬q)"
show False using 1
proof (rule notE)
show 3: "p ∧ q"
proof (rule conjI)
show p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 2 4 by (rule notE)
qed
next
show q
proof (rule ccontr)
assume "¬q" hence 5: "¬p ∨ ¬q" by (rule disjI2)
show False using 2 5 by (rule notE)
qed
qed
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_57_1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_56_1)
with assms show "False" by (rule notE)
qed

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

(* pabalagon manperjim josgomrom4 marfruman1 juacanrod pabbergue alikan *)
lemma ejercicio_58:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "(p ⟶ q) ∨ ¬(p ⟶ q)" proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ ¬(p ⟶ q))"
have 2: "¬(p ⟶ q)" proof (rule notI)
assume "p ⟶ q"
hence 3: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
hence 4: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed
thus ?thesis proof (rule disjE)
assume "p ⟶ q" thus ?thesis by (rule disjI1)
next
assume 1: "¬(p ⟶ q)"
have "q ⟶ p" proof (rule impI)
assume 2: q
have 3: "p ⟶ q" proof (rule impI)
assume p show q using 2 .
qed
show p using 1 3 by (rule notE)
qed
thus ?thesis by (rule disjI2)
qed
qed

(* pabalagon gleherlop chrgencar *)
lemma ejercicio_58_2:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "(p ∧ ¬q) ∧ (q ∧ ¬p)" by simp
hence "p ∧ ¬q" ..
hence 2: p ..
have "q ∧ ¬p" using 1 ..
hence 3: "¬p" ..
show False using 3 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_58_1:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume "¬ ((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "¬(p ⟶ q) ∧ ¬(q ⟶ p)" by (rule ejercicio_46_1)

have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
moreover {
assume "¬p"
hence "p ⟶ q" by (rule ejercicio_40_1)

have "¬(p ⟶ q)" using 1 by (rule conjunct1)
hence "False" using `p ⟶ q` by (rule notE)
}
ultimately show "False" by (rule disjE)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
qed

(* alfmarcua *)
lemma ejercicio_58_3:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
show "p ∨ ¬ p" by (rule ejercicio_52)
next
assume "¬p"
then have "p ⟶ q" by (rule ejercicio_40)
then show ?thesis by (rule disjI1)
next
assume "p"
then have "q ⟶ p" by (rule ejercicio_7)
then show ?thesis by (rule disjI2)
qed

end
</source>

Relación 5

2019-03-06T18:50:02Z

Jalonso: Protegió «Relación 5» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

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

theory R5_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 h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

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

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H x) = [x]" |
"preOrden (N x i d) = x # preOrden i @ preOrden d"

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

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H x) = [x]" |
"postOrden (N x i d) = postOrden i @ postOrden d @ [x]"

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

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
gleherlop cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1
pabbergue alikan juacanrod antramhur *)
fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H x) = [x]" |
"inOrden (N x i d) = inOrden i @ [x] @ inOrden d"

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

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

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
gleherlop cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1
pabbergue alikan juacanrod antramhur *)
fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H x) = H x" |
"espejo (N x i d) = N x (espejo d) (espejo i)"

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

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

(* pabalagon manperjim raffergon2 josgomrom4 hugrubsan cammonagu
alfmarcua gleherlop enrparalv marfruman1 chrgencar pabbergue giafus1
alikan juacanrod aribatval antramhur *)
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 "... = rev (postOrden d @ [x]) @ rev (postOrden i)" by simp
also have "... = rev (postOrden i @ postOrden d @ [x])" by simp
finally show "?P (N x i d)" by simp
qed

(* benber *)
lemma "preOrden (espejo a) = rev (postOrden a)"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have "preOrden (espejo (N v l r)) =
preOrden (N v (espejo r) (espejo l))" by simp
also have "... = v # (preOrden (espejo r)) @ (preOrden (espejo l))"
by simp
also have "... = v # rev (postOrden r) @ rev (postOrden l)"
using IS.IH by simp
also have "... = rev ((postOrden l) @ (postOrden r) @ [v])" by simp
also have "... = rev (postOrden (N v l r))" by simp
finally show ?case .
qed

(* cammonagu *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induction a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan aribatval *)
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" and 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 i @ preOrden d) @ rev [x]" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* raffergon2 alfmarcua marfruman1 juacanrod antramhur *)
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
finally show "?P (N x i d)" by simp
qed

(* benber cammonagu *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induction a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan juacanrod aribatval *)
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 H1: "?P i" and 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
also have "... = rev (inOrden i @ [x] @ inOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* raffergon2 alfmarcua marfruman1 antramhur *)
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 H1: "?P i"
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
also have "... = rev(x # inOrden d) @ rev (inOrden i)" by simp
also have "... = rev(inOrden i @ x # inOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* benber *)
theorem "inOrden (espejo a) = rev (inOrden a)"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have "inOrden (espejo (N v l r)) =
inOrden (N v (espejo r) (espejo l))" by simp
also have "... = (inOrden (espejo r)) @ [v] @ (inOrden (espejo l))"
by simp
also have "... = (rev (inOrden r)) @ [v] @ (rev (inOrden l))"
using IS.IH by simp
also have "... = rev ((inOrden l) @ [v] @ (inOrden r))" by simp
also have"... = rev (inOrden (N v l r))" by simp
finally show ?case .
qed

(* cammonagu*)
lemma "inOrden (espejo a) = rev (inOrden a)"
by (induction a) auto

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

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
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
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 benber josgomrom4 gleherlop hugrubsan
cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1 pabbergue
alikan juacanrod aribatval antramhur *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x" |
"extremo_izquierda (N x i d) = extremo_izquierda i"

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

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

(* pabalagon manperjim raffergon2 benber josgomrom4 hugrubsan cammonagu
alfmarcua gleherlop enrparalv marfruman1 chrgencar giafus1 pabbergue
alikan juacanrod antramhur *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x" |
"extremo_derecha (N x i d) = extremo_derecha d"

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

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
enrparalv gleherlop chrgencar marfruman1 giafus1 pabbergue alikan
juacanrod antramhur *)
lemma inOrdenNotNil: "inOrden a ≠ []" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
have "?P (N x i d) = ((inOrden i @ [x] @ inOrden d) ≠ [])" by simp
also have "... = ((inOrden i ≠ []) ∨ ([x] ≠ []) ∨ (inOrden d ≠ []))"
by simp
also have "... = ([x] ≠ [])" by simp
finally show "?P (N x i d)" by simp
qed

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 HI: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by simp
also have "... = last (x # inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add: inOrdenNotNil)
also have "... = extremo_derecha d" using HI by simp
also have "... = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" .
qed

(* benber *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have 1: "last (xs@ys) = last ys" if "ys ≠ []" for xs ys :: "'a list"
proof (induction xs)
case Nil
show ?case by simp
next
case IS: (Cons x xs)
have "last ((x#xs)@ys) = last (x#(xs@ys))" by simp
also have "... = last (xs @ ys)" using `ys ≠ []` by simp
also have "... = last ys" using IS.IH by simp
finally show ?case .
qed
have 2: "inOrden a ≠ []" for a :: "'a arbol"
by (induction a) auto
have "last (inOrden (N v l r)) =
last ( (inOrden l) @ [v] @ (inOrden r) )" by simp
also have "... = last (inOrden r)" using 1 2 by auto
also have "... = extremo_derecha r" using IS.IH by simp
also have "... = extremo_derecha (N v l r)" by simp
finally show ?case .
qed

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop enrparalv marfruman1 chrgencar giafus1 pabbergue alikan
juacanrod aribatval antramhur *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x::'a
have "hd (inOrden (H x)) = hd [x]" by simp
also have "... = x" by simp
also have "... = extremo_izquierda (H x)" by simp
finally show "?P (H x)" .
next
fix x i d
assume HI: "?P i"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by simp
also have "... = hd ((inOrden i @ [x]) @ inOrden d)" by simp
also have "... = hd (inOrden i)" by (simp add: inOrdenNotNil)
also have "... = extremo_izquierda i" using HI by simp
also have "... = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" .
qed

(* benber *)
theorem "hd (inOrden a) = extremo_izquierda a"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
moreover have "inOrden a ≠ []" for a :: "'a arbol"
by (induction a) auto
ultimately show ?case by simp
qed

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop marfruman1 chrgencar giafus1 pabbergue alikan juacanrod
aribatval antramhur *)
theorem hdPreOrden_lastPostOrden:
"hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "hd (preOrden (N x i d)) = hd (x # preOrden i @ preOrden d)"
by simp
also have "... = x" by simp
also have "... = last [x]" by simp
also have "... = last (postOrden i @ postOrden d @ [x])" by simp
finally show "?P (N x i d)" by simp
qed

(* enrparalv *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x::'a
have "hd (preOrden (H x)) = hd [x]" by simp
also have "... = x" by simp
also have "... = last [x]" by simp
also have "... = last (postOrden (H x))" by simp
finally show "?P (H x)" by simp
next
fix x i d
have "hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)"
by simp
also have "... = hd ([x] @ preOrden i)" by simp
also have "... = x" by simp
also have "... = last [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
oops

(* benber cammonagu *)
theorem "hd (preOrden a) = last (postOrden a)"
by (cases a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop marfruman1 chrgencar giafus1 pabbergue alikan juacanrod
aribatval antramhur *)
theorem hdPreOrden_raiz: "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "hd (preOrden (N x i d)) = hd (x # preOrden i @ preOrden d)"
by simp
also have "... = x" by simp
finally show "?P (N x i d)" by (simp only: raiz.simps(2))
qed

(* enrparalv *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x::'a
have "hd (preOrden (H x)) = hd [x]" by simp
also have "... = x " by simp
also have "... = raiz (H x)" by (simp only: raiz.simps(1))
finally show "?P (H x)" by simp
next
fix x i d
have "hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = hd (([x] @ preOrden i) @ preOrden d)" by simp
also have "... = hd ([x] @ preOrden i)" by simp
also have "... = hd ([x])" by simp
also have "... = x" by simp
finally show "?P (N x i d)" by (simp only: raiz.simps(2))
oops

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

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

(* pabalagon manperjim cammonagu alfmarcua marfruman1 gleherlop
chrgencar giafus1 pabbergue juacanrod hugrubsan alikan aribatval
antramhur *)
theorem "hd (inOrden a) = raiz a"
quickcheck
(*
Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)
oops

(* benber josgomrom4 *)
(* El teorema no es cierto para arboles sobre numeros naturales *)
theorem "¬(∀ a :: nat arbol. hd (inOrden a) = raiz a)"
proof -
let ?a = "(N 0 (H 1) (H 2)) :: nat arbol"
have "hd (inOrden ?a) = 1" by simp
moreover have "raiz ?a = 0" by simp
ultimately have "hd (inOrden ?a) ≠ raiz ?a" by simp
hence "∃ a :: nat arbol. hd (inOrden a) ≠ raiz a" by (simp only: exI)
thus ?thesis by auto
qed

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

(* pabalagon manperjim josgomrom4 cammonagu marfruman1 gleherlop
chrgencar giafus1 pabbergue juacanrod hugrubsan aribatval antramhur *)
theorem "last (postOrden a) = raiz a"
proof -
have "last (postOrden a) = hd (preOrden a)"
by (simp add: hdPreOrden_lastPostOrden)
also have "... = raiz a" by (simp add: hdPreOrden_raiz)
finally show "?thesis" .
qed

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

(* alfmarcua *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "last (postOrden (N x i d)) =
last (postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
finally show "?P (N x i d)" by simp
qed

(* enrparalv *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x::'a
have "last (postOrden (H x)) = last [x]" by simp
also have "... = x" by simp
also have "... = raiz (H x)" by (simp only: raiz.simps(1))
finally show "?P (H x)" by simp
next
fix x i 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 only: raiz.simps(2))
finally show "?P (N x i d)" by simp
oops

end
</source>

Relación 4

2019-03-06T18:49:39Z

Jalonso: Protegió «Relación 4» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* R4: Cuantificadores sobre listas *}

theory R4_Cuantificadores_sobre_listas
imports Main
begin

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

Nota: La función todos es equivalente a la predefinida list_all.
---------------------------------------------------------------------
*}

(* manperjim pabalagon alfmarcua josgomrom4 aribatval cammonagu
raffergon2 enrparalv gleherlop chrgencar benber giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True" |
"todos p (x#xs) = (p x ∧ todos p xs)"

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

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

(* manperjim pabalagon alfmarcua josgomrom4 cammonagu aribatval
raffergon2 enrparalv gleherlop chrgencar benber giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan *)
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False" |
"algunos p (x#xs) = (p x ∨ algunos p xs)"

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

(* manperjim pabalagon alfmarcua josgomrom4 cammonagu raffergon2
enrparalv gleherlop chrgencar benber giafus1 pabbergue alikan
marfruman1 antramhur juacanrod hugrubsan aribatval *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

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

(* pabalagon *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P P Q xs")
proof (induct xs)
fix P Q
show "?P P Q []" by simp
next
fix a xs
assume HI: "?P P Q xs"
have "todos (λx. P x ∧ Q x) (a#xs) =
((P a ∧ Q a) ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
also have "... = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))"
by (simp add: HOL.conj_comms)
also have "... = (todos P (a#xs) ∧ (Q a ∧ todos Q xs))" by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) =
(todos P (a#xs) ∧ todos Q (a#xs))" by simp
qed

(* alfmarcua juacanrod *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P xs")
proof (induct xs)
have "todos (λx. P x ∧ Q x) [] = (True)"
by (simp only: todos.simps(1))
also have "... = (True ∧ True)" by (simp only: conj_absorb)
also have "... = (todos P [] ∧ todos Q [])"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix x xs
assume HI: "?P xs"
have "todos (λx. P x ∧ Q x) (x # xs) =
((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)"
by (simp only: todos.simps(2))
also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))"
by (simp only: HI)
also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))"
by (simp only: HOL.conj_comms)
also have "... = (todos P (x # xs) ∧ todos Q (x # xs))"
by (simp only: todos.simps(2))
finally show "?P (x#xs)" .
qed

(* manperjim josgomrom4 raffergon2 cammonagu enrparalv gleherlop
chrgencar giafus1 pabbergue alikan marfruman1 antramhur hugrubsan
aribatval *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
((P n ∧ Q n) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P n ∧ todos P xs) ∧ (Q n ∧ todos Q xs))" by arith
also have "... = ((todos P(n#xs)) ∧ (todos Q(n#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (n#xs) =
(todos P (n#xs) ∧ todos Q (n#xs))" by simp
qed

(* benber *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
case Nil
have "todos (λx. P x ∧ Q x) [] = True" by (simp only: todos.simps(1))
also have "... = (todos P [] ∧ todos Q [])"
by (simp only: todos.simps(1) conj_absorb)
finally show ?case.
next
case (Cons x xs)
assume IH: "todos (λy. P y ∧ Q y) xs = (todos P xs ∧ todos Q xs)"
have "todos (λy. P y ∧ Q y) (x # xs) =
( (P x ∧ Q x) ∧ todos (λy. P y ∧ Q y) xs )"
by (simp only: todos.simps(2))
also have "... = ( (P x ∧ Q x) ∧ todos P xs ∧ todos Q xs )"
by (simp only: IH)
also have "... = ( P x ∧ (Q x ∧ todos P xs) ∧ todos Q xs )"
by (simp only: conj_assoc)
also have "... = ( P x ∧ (todos P xs ∧ Q x) ∧ todos Q xs )"
by (simp only: conj_commute)
also have "... = ( (P x ∧ todos P xs) ∧ Q x ∧ todos Q xs )"
by (simp only: conj_assoc)
also have "... = ( todos P (x#xs) ∧ todos Q (x#xs) )"
by (simp only: todos.simps(2))
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* manperjim pabalagon alfmarcua josgomrom4 aritbatval cammonagu
raffergon2 enrparalv benber gleherlop chrgencar giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan aribatval *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan antramhur juacanrod
hugrubsan *)
lemma todos_append:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp
finally show "todos P ((a#x) @ y) = (todos P (a#x) ∧ todos P y)"
by simp
qed

(* alfmarcua marfruman1 *)
lemma todos_append_2:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?P x")
proof (induct x)
have "todos P ([] @ y) = todos P y" by (simp only: append_Nil)
also have "... = (True ∧ todos P y)" by (simp only: simp_thms(22))
also have "... = (todos P [] ∧ todos P y)"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix a x
assume HI:"?P x"
have "todos P ((a # x) @ y) = todos P (a # (x @ y))"
by (simp only:List.append.append_Cons)
also have "... = (P a ∧ todos P (x @ y))"
by (simp only: todos.simps(2))
also have "... = (P a ∧ todos P x ∧ todos P y)" by (simp only:HI)
also have "... = ((P a ∧ todos P x) ∧ todos P y)"
by (simp only:HOL.conj_assoc)
also have "... = (todos P (a#x) ∧ todos P y)"
by (simp only: todos.simps(2))
finally show "?P (a#x)" .
qed

(* benber *)
lemma todos_append_3:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x )
case Nil
have "todos P ( [] @ y ) = todos P y"
by (simp only: List.append.left_neutral)
also have "... = (todos P [] ∧ todos P y)"
by (simp only: todos.simps(1) simp_thms(22))
finally show ?case.
next
case (Cons a x)
assume IH: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))"
by (simp only: todos.simps(2) List.append.append_Cons)
also have "... = (P a ∧ todos P x ∧ todos P y)" by (simp only: IH)
also have "... = (todos P (a#x) ∧ todos P y)"
by (simp only: todos.simps(2) conj_assoc )
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua aribatval cammonagu
raffergon2 giafus1 pabbergue enrparalv alikan antramhur juacanrod
hugrubsan *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (simp_all add: HOL.conj_comms todos_append)

(* benber marfruman1*)
lemma "todos P (rev xs) = todos P xs"
using todos_append by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 cammonagu gleherlop giafus1
pabbergue enrparalv marfruman1 alikan chrgencar antramhur juacanrod
hugrubsan aribatval *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P xs ∧ P a)" by simp
also have "... = (P a ∧ todos P xs)" by (simp add: HOL.conj_comms)
finally show "todos P (rev (a#xs)) = todos P (a#xs)" by simp
qed

(* alfmarcua *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: rev.simps(1))
next
fix a xs
assume HI:"?P xs"
have "todos P (rev (a # xs)) = todos P (rev xs @ [a])"
by (simp only: rev.simps(2))
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp only: todos_append)
also have "... = (todos P xs ∧ todos P [a])" by (simp only: HI)
also have "... = (todos P (a#[]) ∧ todos P xs)"
by (simp only: HOL.conj_comms)
also have "... = ((P a ∧ True) ∧ todos P xs)"
by (simp only: todos.simps)
also have "... = (P a ∧ todos P xs)"
by (simp only: HOL.simp_thms(21))
also have "... = todos P (a#xs)" by (simp only: todos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
case Nil
show "todos P (rev []) = todos P []" by (simp only: rev.simps(1))
next
case (Cons x xs)
assume IH: "todos P (rev xs) = todos P xs"
have "todos P (rev (x#xs)) = todos P (rev xs @ [x])"
by (simp only: rev.simps(2))
also have "... = (todos P (rev xs) ∧ todos P [x] )"
by (simp only: todos_append)
also have "... = (todos P (rev xs) ∧ P x ∧ todos P [])"
by (simp only: todos.simps(2))
also have "... = (todos P (rev xs) ∧ P x)"
by (simp only: todos.simps(1) simp_thms(21))
also have "... = (todos P xs ∧ P x)" by (simp only: IH)
also have "... = (todos P (x#xs))"
by (simp only: todos.simps(2) conj_commute)
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar o refutar:
algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)
---------------------------------------------------------------------
*}

(* pabalagon *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
nitpick
oops

(* Contraejemplo *)
value "algunos (λx. even x ∧ odd x) [1, 2::nat] ≠
algunos even [1, 2::nat] ∧ algunos odd [1, 2::nat]"

(* manperjim alfmarcua raffergon2 gleherlop chrgencar cammonagu giafus1
pabbergue marfruman1 alikan antramhur juacanrod hugrubsan
aribatval *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
quickcheck
oops

(* benber (demostración no completa) *)
fun is_zero :: "nat ⇒ bool" where
"is_zero n = (n = 0)"
fun is_one :: "nat ⇒ bool" where
"is_one n = (n = 1)"
lemma "¬( ∀P Q xs. algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs) )"
proof -
let ?P = is_one
let ?Q = is_zero
have "algunos (λx. ?P x ∧ ?Q x) [0,1] ≠
(algunos ?P [0,1] ∧ algunos ?Q [0,1])" by simp
hence "∃ xs. algunos (λx. ?P x ∧ ?Q x) xs ≠
(algunos ?P xs ∧ algunos ?Q xs)" by (simp only: exI)
hence "∃Q xs. algunos (λx. ?P x ∧ Q x) xs ≠
(algunos ?P xs ∧ algunos Q xs)"
by (simp only: exI[of "λQ. ∃ xs. algunos (λx. ?P x ∧ Q x) xs ≠ (algunos ?P xs ∧ algunos Q xs)"])
hence "∃P Q xs. algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)"
(*
No sé por qué esto no funciona:
by (simp only: exI[of "λP Q xs. algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)" ?P])

Parece que el problema es la expresión lambda.
*)
sorry
thus ?thesis by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 7.1. Demostrar o refutar automáticamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 gleherlop
cammonagu benber giafus1 pabbergue enrparalv marfruman1 alikan
antramhur juacanrod hugrubsan aribatval *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) auto

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

(* manperjim pabalagon cammonagu giafus1 gleherlop chrgencar pabbergue
enrparalv marfruman1 alikan antramhur juacanrod hugrubsan *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a#xs)) = (P (f a) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by simp
also have "... = ((P ∘ f) a ∨ algunos (P ∘ f) xs)" by simp
finally show "algunos P (map f (a#xs)) = algunos (P ∘ f) (a#xs)"
by simp
qed

(* josgomrom4 *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P o f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P o f) xs"
have "algunos P (map f (x#xs)) = (P (f x) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f x) ∨ algunos (P o f) xs)" using HI by simp
finally show "algunos P (map f (x#xs)) = algunos (P o f) (x#xs)"
by simp
qed

(* alfmarcua *)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?P xs")
proof (induct xs)
have "algunos P (map f []) = algunos P []"
by (simp only: List.list.map(1))
also have "... = algunos (P o f) []" by (simp only: algunos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P (map f (a # xs)) = algunos P (f a # map f xs)"
by (simp only: List.list.map(2))
also have "... = (P (f a) ∨ algunos P (map f xs))"
by (simp only: algunos.simps(2))
also have "... = (P (f a) ∨ algunos (P o f) xs)" by (simp only:HI)
also have "... = ((P o f) a ∨ algunos (P o f) xs)"
by (simp only: Fun.comp_apply)
also have "... = algunos (P o f) (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
case Nil
have "algunos P (map f []) = algunos P []" by (simp only: list.map(1))
also have "... = False" by (simp only: algunos.simps(1))
also have "False = algunos (P ∘ f) []" by (simp only: algunos.simps(1))
finally show ?case.
next
case (Cons x xs)
assume IH: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (x # xs)) = algunos P (f x # map f xs)"
by (simp only: list.map(2))
also have "... = ( (P ∘ f) x ∨ algunos P (map f xs) )"
by (simp only: algunos.simps(2) o_apply)
also have "... = ( (P ∘ f) x ∨ algunos (P ∘ f) xs )"
by (simp only: IH)
also have "... = algunos (P ∘ f) (x#xs)"
by (simp only: algunos.simps(2))
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
alikan antramhur juacanrod hugrubsan aribatval *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 gleherlop cammonagu giafus1
pabbergue enrparalv marfruman1 alikan antramhur juacanrod hugrubsan *)
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a#xs) @ ys) = (P a ∨ algunos P (xs @ ys))" by simp
also have "... = (P a ∨ algunos P xs ∨ algunos P ys)" using HI by simp
finally show "algunos P ((a#xs) @ ys) =
(algunos P (a#xs) ∨ algunos P ys)" by simp
qed

(* alfmarcua *)
lemma algunos_append_2:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?P xs")
proof (induct xs)
have "algunos P ([] @ ys) = algunos P ys" by (simp only: append_Nil)
also have "... = (False ∨ algunos P ys)" by (simp only: simp_thms(32))
also have "... = (algunos P [] ∨ algunos P ys)"
by (simp only: algunos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P ((a # xs) @ ys) = algunos P (a # (xs @ ys))"
by (simp only:List.append.append_Cons)
also have "... = (P a ∨ algunos P (xs @ ys))"
by (simp only: algunos.simps(2))
also have "... = (P a ∨ algunos P xs ∨ algunos P ys)"
by (simp only:HI)
also have "... = ((P a ∨ algunos P xs) ∨ algunos P ys)"
by (simp only:HOL.disj_assoc)
also have "... = (algunos P (a#xs) ∨ algunos P ys)"
by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma algunos_append_3:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
case Nil
have "algunos P ([] @ ys) = algunos P ys"
by (simp only: append.left_neutral)
also have "... = ( algunos P [] ∨ algunos P ys )"
by (simp only: algunos.simps(1) simp_thms(32))
finally show ?case .
next
case (Cons x xs)
assume IH: "algunos P (xs @ ys) = ( algunos P xs ∨ algunos P ys )"
have "algunos P ((x#xs) @ ys) = algunos P (x#(xs @ ys))"
by (simp only: append_Cons)
also have "... = ( P x ∨ algunos P (xs @ ys) )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ algunos P xs ∨ algunos P ys )"
by (simp only: IH)
also have "... = ( algunos P (x#xs) ∨ algunos P ys )"
by (simp only: algunos.simps(2) disj_assoc)
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 gleherlop chrgencar
cammonagu giafus1 pabbergue enrparalv alikan antramhur juacanrod
hugrubsan aribatval *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs) (simp_all add: HOL.disj_comms algunos_append)

(* benber marfruman1 *)
lemma "algunos P (rev xs) = algunos P xs"
using algunos_append by (induct xs) auto

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

(* pabalagon juacanrod *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a#xs)) = algunos P (rev xs @ [a])" by simp
also have "... = (algunos P (rev xs) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P xs ∨ P a)" by simp
also have "... = (P a ∨ algunos P xs)" by (simp add: HOL.disj_comms)
finally show "algunos P (rev (a#xs)) = algunos P (a#xs)" by simp
qed

(* manperjim josgomrom4 raffergon2 gleherlop chrgencar cammonagu giafus1
pabbergue enrparalv marfruman1 alikan antramhur hugrubsan *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI:"algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a # xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = ((algunos P (rev xs)) ∨ (algunos P [a]))"
by (simp add: algunos_append)
also have "... = ((algunos P xs) ∨ (algunos P [a]))" using HI by simp
also have "... = ((algunos P [a]) ∨ (algunos P xs))" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* alfmarcua *)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: rev.simps(1))
next
fix a xs
assume HI:"?P xs"
have "algunos P (rev (a # xs)) = algunos P (rev xs @ [a])"
by (simp only: rev.simps(2))
also have "... = (algunos P (rev xs) ∨ algunos P [a])"
by (simp only: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" by (simp only: HI)
also have "... = (algunos P (a#[]) ∨ algunos P xs)"
by (simp only: HOL.disj_comms)
also have "... = ((P a ∨ False) ∨ algunos P xs)"
by (simp only: algunos.simps)
also have "... = (P a ∨ algunos P xs)"
by (simp only: HOL.simp_thms(31))
also have "... = algunos P (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
case Nil
show ?case by (simp only: algunos.simps(1) rev.simps(1))
next
case (Cons x xs)
assume IH: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (x#xs)) = algunos P ( (rev xs) @ [x] )"
by (simp only: rev.simps(2))
also have "... = ( algunos P (rev xs) ∨ algunos P [x] )"
by (simp only: algunos_append)
also have "... = ( algunos P (rev xs) ∨ P x ∨ algunos P [] )"
by (simp only: algunos.simps(2))
also have "... = ( algunos P (rev xs) ∨ P x )"
by (simp only: algunos.simps(1) simp_thms(31))
also have "... = (algunos P xs ∨ P x)" by (simp only: IH)
also have "... = algunos P (x#xs)"
by (simp only: algunos.simps(2) disj_commute)
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la
siguiente ecuación:
algunos (λx. P x ∨ Q x) xs = Z
y demostrar la equivalencia de forma automática y detallada.
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 enrparalv marfruman1 antramhur
alikan hugrubsan aribatval *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

(* pabalagon josgomrom4 cammonagu pabbergue marfruman1 antramhur
juacanrod alikan *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix a xs
assume HI: "algunos (λx. P x ∨ Q x) xs =
(algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a#xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "... = (P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)"
by (simp add: HOL.disj_comms)
finally show "algunos (λx. P x ∨ Q x) (a#xs) =
(algunos P (a#xs) ∨ algunos Q (a#xs))" by simp
qed

(* alfmarcua *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by (simp only: algunos.simps(1) HOL.simp_thms(33))
next
fix a xs
assume HI:"?P xs"
have "algunos (λx. P x ∨ Q x) (a # xs) =
((P a ∨ Q a) ∨ algunos (λx. P x ∨ Q x) xs)"
by (simp only: algunos.simps(2))
also have "... = ((P a ∨ Q a) ∨ algunos P xs ∨ algunos Q xs)"
by (simp only: HI)
also have "... = ((P a ∨ algunos P xs) ∨ Q a ∨ algunos Q xs)"
by (simp only: HOL.disj_assoc HOL.disj_comms)
also have "... = (algunos P (a # xs) ∨ algunos Q (a # xs))"
by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos (λx. P x ∨ Q x) xs = ( algunos P xs ∨ algunos Q xs )"
proof (induct xs)
case Nil
have "algunos (λx. P x ∨ Q x) [] = False"
by (simp only: algunos.simps(1))
also have "... = ( algunos P [] ∨ algunos Q [] )"
by (simp only: algunos.simps(1) simp_thms(31))
finally show ?case.
next
case (Cons x xs)
let ?R = "λx. P x ∨ Q x"
assume IH: "algunos ?R xs = ( algunos P xs ∨ algunos Q xs )"
have "algunos ?R (x#xs) = ( ?R x ∨ algunos ?R xs )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ Q x ∨ algunos P xs ∨ algunos Q xs )"
by (simp only: IH disj_assoc)
also have "... = ( P x ∨ (Q x ∨ algunos P xs) ∨ algunos Q xs )"
by (simp only: disj_assoc)
also have "... = ( P x ∨ (algunos P xs ∨ Q x) ∨ algunos Q xs )"
by (simp only: disj_commute)
also have "... = ( algunos P (x#xs) ∨ algunos Q (x#xs) )"
by (simp only: algunos.simps(2) disj_assoc)
finally show ?case .
qed

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

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
antramhur juacanrod alikan hugrubsan aribatval *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 cammonagu pabbergue enrparalv
marfruman1 antramhur juacanrod alikan hugrubsan aribatval *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
have "algunos P [] = False" by simp
also have "... = (¬ todos (λx. (¬ P x)) [])" by simp
finally show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "(¬ todos (λx. (¬ P x)) (a#xs)) =
(¬ ((¬ P a) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "... = (P a ∨ ¬ todos (λx. (¬ P x)) xs)" by simp
also have "... = (P a ∨ algunos P xs)" using HI by simp
finally show "algunos P (a#xs) = (¬ todos (λx. (¬ P x)) (a#xs))"
by simp
qed

(* alfmarcua *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)" (is "?P xs")
proof (induct xs)
have "algunos P [] = False" by (simp only:algunos.simps(1))
also have "... = (¬ True)" by (simp only: HOL.simp_thms(7))
also have "... = (¬ todos (λx. (¬ P x)) [])"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P (a # xs) = (P a ∨ algunos P xs)"
by (simp only: algunos.simps(2))
also have "... = (P a ∨ ¬ todos (λx. (¬ P x)) xs)"
by (simp only: HI)
also have "... = (¬ ¬ P a ∨ ¬ todos (λx. (¬ P x)) xs)"
by (simp only: HOL.simp_thms(1))
also have "... = (¬ (¬ P a ∧ todos (λx. (¬ P x)) xs))"
by (simp only: HOL.de_Morgan_conj)
also have "... = (¬ todos (λx. (¬ P x)) (a#xs))"
by (simp only: todos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
case Nil
have "algunos P [] = False" by (simp only: algunos.simps(1))
also have "False = (¬ todos (λx. ¬ P x) [])"
by (simp only: todos.simps(1) not_True_eq_False)
finally show ?case .
next
case (Cons x xs)
assume IH: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (x#xs) = ( P x ∨ algunos P xs )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ (¬ todos (λx. (¬ P x)) xs) )"
by (simp only: IH)
also have "... = ( ¬( ¬ P x ∧ todos (λx. (¬ P x)) xs) )"
by (simp only: not_not de_Morgan_conj)
also have "... = (¬ todos (λx. (¬ P x)) (x#xs))"
by (simp only: todos.simps(2))
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
antramhur juacanrod alikan hugrubsan aribatval *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False" |
"estaEn x (y#xs) = (x=y ∨ estaEn x xs)"

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

(* manperjim pabalagon josgomrom4 alfmarcua cammonagu gleherlop
chrgencar benber giafus1 pabbergue marfruman1 antramhur juacanrod
alikan *)
lemma "estaEn x xs = algunos (λa. x=a) xs"
by (induct xs) auto

(* pabalagon josgomrom4 cammonagu marfruman1 antramhur *)
lemma "estaEn x xs = algunos (λa. x=a) xs"
proof (induct xs)
show "estaEn x [] = algunos (λa. x=a) []" by simp
next
fix y xs
assume HI: "estaEn x xs = algunos (λa. x=a) xs"
have "estaEn x (y#xs) = (x=y ∨ estaEn x xs)" by simp
also have "... = (x=y ∨ algunos (λa. x=a) xs)" using HI by simp
finally show "estaEn x (y#xs) = algunos (λa. x=a) (y#xs)" by simp
qed

(* alfmarcua *)
lemma "estaEn x xs = algunos (λk. x=k) xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: estaEn.simps(1) algunos.simps(1))
next
fix a xs
assume HI:"?P xs"
have "estaEn x (a # xs) = (x=a ∨ estaEn x xs)"
by (simp only: estaEn.simps(2))
also have "... = (x=a ∨ algunos (λk. x=k) xs)" by (simp only: HI)
(* also have "... = ((λk. x=k) a ∨ algunos (λk. x=k) xs)" by (simp only:HOL.simp_thms(6)) *)
also have "... = algunos (λk. x=k) (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "estaEn x xs = (algunos (λy. y = x) xs)"
proof (induct xs)
case Nil
have "estaEn x [] = False" by (simp only: estaEn.simps(1))
also have "False = (algunos (λy. y = x) [])"
by (simp only: algunos.simps(1))
finally show ?case .
next
case (Cons z xs)
assume IH: "estaEn x xs = algunos (λy. y = x) xs"
have "estaEn x (z#xs) = ( z = x ∨ estaEn x xs )" by force
also have "... = ( z = x ∨ algunos (λy. y = x) xs)" by (simp only: IH)
also have "... = (algunos (λy. y = x) (z#xs))"
by (simp only: algunos.simps(2))
finally show ?case .
qed

end
</source>

Relación 3

2019-03-06T18:49:15Z

Jalonso: Protegió «Relación 3» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas
imports Main
begin

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

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

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

(* benber *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + (2*n+1)" by (simp only: HI)
also have "... = n*n + (n+n+1)" by (simp only:)
also have "... = n*n + n + n + 1" by (simp only:)
also have "... = n*n + n*1 + n + 1" by (simp only:)
also have "... = n*(n+1) + n + 1"
by (simp only: Nat.add_mult_distrib2)
also have "... = n*(n+1) + (n+1)" by (simp only:)
also have "... = (n+1)*n + (n+1)"
by (simp only: Groups.ab_semigroup_mult_class.mult.commute)
also have "... = (n+1)*n + (n+1)*1" by (simp only: Nat.nat_mult_1_right)
also have "... = (n+1)*(n+1)" by (simp only: Nat.add_mult_distrib2)
also have "... = (Suc n) * (Suc n)" by (simp only: Nat.Suc_eq_plus1)
finally show "sumaImpares (Suc n) = (Suc n) * (Suc n)" .
qed

(* manperjim pabalagon josgomrom4 hugrubsan enrparalv juacanrod *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2 * n + 1"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = n*n + n + n + 1" by (simp only: Nat.add_mult_distrib)
also have "... = (n+1)*n + (n + 1)" by (simp only: Nat.add_mult_distrib)
also have "... = (n+1)*n + (n + 1)*1" by (simp only: Nat.nat_mult_1_right)
also have "... = (n+1)*(n+1)" by (simp only: Nat.add_mult_distrib2)
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)"
by (simp only: Nat.Suc_eq_plus1)
qed

(* marfruman1 raffergon2 aribatval alfmarcua cammonagu gleherlop
chrgencar alikan pabbergue giafus1 antramhur *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n +1"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = (Suc n)*(Suc n)" by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

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

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

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(* benber josgomrom4 *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
have "sumaPotenciasDeDosMasUno 0 = 2"
by (simp only: sumaPotenciasDeDosMasUno.simps(1))
also have "... = 2^(0+1)" by simp
finally show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" .
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2^(n+1) + 2^(n+1)" by (simp only: HI)
also have "... = 2 * 2^(n+1)" by (simp only:)
also have "... = 2 * 2^(Suc n)" by (simp only: Nat.Suc_eq_plus1)
also have "... = 2^(Suc (Suc n))"
by (simp only: Power.power_class.power.power_Suc)
also have "... = 2^((Suc n)+1)" by (simp only: Nat.Suc_eq_plus1)
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" .
qed

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

(* manperjim pabalagon raffergon2 aribatval cammonagu hugrubsan
pabbergue giafus1 antramhur*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
have "sumaPotenciasDeDosMasUno 0 = 2"
by (simp only: sumaPotenciasDeDosMasUno.simps(1))
also have "... = 2^1" by (simp only: Power.power_one_right)
finally show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)"
by (simp only: Nat.add_0)
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2^(n+1) + 2^(n+1)" by (simp only: HI)
also have "... = 2*2^(n+1)" by (simp only: Nat.add_mult_distrib)
also have "... = 2*2^(Suc n)" by (simp only: Nat.Suc_eq_plus1)
also have "... = 2^(Suc n)*2^1" by (simp only: Power.power_one_right)
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n + 1)"
by (simp only: Power.power_add)
qed

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

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

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

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

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

(* manperjim benber raffergon2 aribatval josgomrom4 hugrubsan cammonagu
gleherlop chrgencar marfruman1 pabbergue giafus1 juacanrod
antramhur *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
fix x :: 'a
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []"
by (simp only: copia.simps(1))
also have "..." by (simp only: todos.simps(1))
finally show "todos (λy. y = x) (copia 0 x)" .
next
fix x :: 'a
fix n :: nat
assume HI: "todos (λy. y = x) (copia n x)"
have "(todos (λy. y = x) (copia (Suc n) x) ) =
(todos (λy. y = x) (x # copia n x))"
by (simp only: copia.simps(2))
also have "... = (((λy. y = x) x ) ∧ todos (λy. y = x) (copia n x) )"
by (simp only: todos.simps(2))
also have "..." by (simp only: HI)
finally show "todos (λy. y = x) (copia (Suc n) x)" .
qed

(* pabalagon *)
lemma "todos (λy. y=x) (copia n x)"
proof (induction n)
fix x:: 'a
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by simp
also have "..." by simp
finally show "todos (λy. y=x) (copia 0 x)" .
next
fix x:: 'a
fix n:: nat
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) =
todos (λy. y=x) (x#(copia n x))" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" using HI by simp
qed

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

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

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

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

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

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

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

(* benber *)
lemma fact: "factI' n x = x * factR n"
proof -
(* Reformulación para aplicar la hipótesis inductiva con un valor
distinto de x. *)
have "∀x. factI' n x = x * factR n"
proof (induct n)
show "∀x. factI' 0 x = x * factR 0"
proof
fix x
have "factI' 0 x = x" by (simp only: factI'.simps(1))
also have "... = x * 1" by (simp only:)
also have "... = x * factR 0" by (simp only: factR.simps(1))
finally show "factI' 0 x = x * factR 0" .
qed
next
show "⋀n. ∀x. factI' n x = x * factR n ⟹
∀x. factI' (Suc n) x = x * factR (Suc n)"
proof
fix x
fix n
assume HI: "∀y. factI' n y = y * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)"
by (simp only: factI'.simps(2))
also have "... = (x * Suc n) * factR n" by (simp only: HI)
also have "... = x * factR (Suc n)" by (simp only: factR.simps(2))
finally show "factI' (Suc n) x = x * factR (Suc n)" .
qed
qed
thus "factI' n x = x * factR n" by simp
qed

(* manperjim pabalagon raffergon2 aribatval josgomrom4 alfmarcua
hugrubsan cammonagu marfruman1 gleherlop chrgencar pabbergue giafus1
juacanrod antramhur *)
lemma fact2: "factI' n x = x * factR n"
proof (induction n arbitrary: x)
fix x
have "factI' 0 x = x" by simp
also have "... = x * 1" by simp
finally show "factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)"
by (simp only: factI'.simps(2))
also have "... = x * Suc n * factR n" using HI by simp
finally show "factI' (Suc n) x = x*factR (Suc n)"
by (simp only: factR.simps(2))
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

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

(* manperjim pabalagon raffergon2 josgomrom4 alfmarcua hugrubsan
marfruman1 gleherlop chrgencar pabbergue giafus1 juacanrod
antramhur *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by (simp only: factI.simps(1))
also have "... = 1*factR n" using fact by simp
finally show "factI n = factR n" by (simp only: mult_1)
qed

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

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

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* benber aribatval alfmarcua giafus1 *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
also have "... = [] @ [y]" by (simp only: List.append.left_neutral)
finally show "amplia [] y = [] @ [y]" .
next
fix x
fix xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x # amplia xs y" by (simp only: amplia.simps(2))
also have "... = x # (xs @ [y])" by (simp only: HI)
also have "... = (x#xs) @ [y]" by (simp only: List.append.append_Cons)
finally show "amplia (x#xs) y = (x#xs) @ [y]" .
qed

(* marfruman1 raffergon2 enrparalv alikan gleherlop chrgencar
juacanrod *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
also have "... = [] @ [y]" by simp
finally show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x# amplia xs y" by (simp only: amplia.simps(2))
also have "... = x# (xs @ [y])" using HI by simp
also have "... = (x#xs) @ [y]" by simp
finally show "amplia (x#xs) y =(x#xs) @ [y]" by simp
qed

(* manperjim pabalagon josgomrom4 hugrubsan cammonagu pabbergue
antramhur*)
lemma "amplia xs y = xs @ [y]"
proof (induction xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
show "amplia [] y = [] @ [y]" by simp
next
fix a xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (a#xs) y = a # amplia xs y"
by (simp only: amplia.simps(2))
also have "... = a # (xs @ [y])" using HI by simp
finally show "amplia (a#xs) y = (a#xs) @ [y]" by simp
qed

end
</source>

Relación 2

2019-03-06T18:48:53Z

Jalonso: Protegió «Relación 2» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

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

theory R2_Razonamiento_automatico_sobre_programas
imports Main
begin

declare [[names_short]]

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
hugrubsan enrparalv gleherlop chrgencar giafus1 pabbergue alikan
aribatval *)
fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0" |
"sumaImpares n = 2*n-1 + sumaImpares (n-1)"

value "sumaImpares 1 = 1"
value "sumaImpares 3 = 9"
value "sumaImpares 5 = 25"

(* josgomrom4 marfruman1 benber antramhur *)
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0" |
"sumaImpares2 (Suc n) = 2*n + 1 + sumaImpares2 n"

value "sumaImpares2 1 = 1"
value "sumaImpares2 3 = 9"
value "sumaImpares2 5 = 25"

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

(* manperjim pabalagon cammonagu juacanrod josgomrom4 hugrubsan
enrparalv gleherlop benber chrgencar giafus1 alikan aribatval *)
lemma "sumaImpares n = n*n"
apply (induction n)
apply auto
done

(* pabalagon *)
lemma "sumaImpares n = n*n"
apply (induction n)
apply simp
apply simp
done

(* pabalagon antramhur *)
lemma "sumaImpares n = n*n"
by (induction n) simp_all

(* alfmarcua raffergon2 marfruman1 pabbergue *)
lemma "sumaImpares n = n*n"
by (induction n) auto

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

(* manperjim pabalagon cammonagu chrgencar hugrubsan gleherlop benber
pabbergue aribatval *)
fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2" |
"sumaPotenciasDeDosMasUno (Suc n) =
2^(n+1) + sumaPotenciasDeDosMasUno n"

value "sumaPotenciasDeDosMasUno 3 = 16"

(* juacanrod josgomrom4 marfruman1 antramhur *)
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2" |
"sumaPotenciasDeDosMasUno2 (Suc n) =
2^(Suc n) + sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3 = 16"

(* alfmarcua raffergon2 enrparalv alikan giafus1 *)
fun sumaPotenciasDeDosMasUno3 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno3 0 = 2" |
"sumaPotenciasDeDosMasUno3 n = 2^n + sumaPotenciasDeDosMasUno3 (n-1)"

value "sumaPotenciasDeDosMasUno3 3 = 16"

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan enrparalv benber chrgencar gleherlop giafus1
pabbergue alikan aribatval *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induction n)
apply auto
done

(* pabalagon antramhur *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induction n) simp_all

(* marfruman1 *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) auto

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

(* manperjim pabalagon cammonagu josgomrom4 hugrubsan benber gleherlop
chrgencar pabbergue alikan antramhur aribatval *)
fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []" |
"copia (Suc n) x = x#copia n x"

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

(* juacanrod marfruman1 *)
fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []" |
"copia2 (Suc n) x = [x] @ copia2 n x"

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

(* manperjim alfmarcua raffergon2 enrparalv giafus1 *)
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []" |
"copia3 n x = x#(copia (n-1) x)"

value "copia3 3 x = [x,x,x]"

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 marfruman1 hugrubsan enrparalv benber chrgencar giafus1
gleherlop pabbergue alikan antramhur aribatval *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True" |
"todos p (x#xs) = (p x ∧ todos p xs)"

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

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan enrparalv benber giafus1 pabbergue alikan
gleherlop chrgencar aribatval *)
lemma "todos (λy. y=x) (copia n x)"
apply (induction n)
apply auto
done

(* Comentario: La demostración anterior falla para copia3. *)

(* pabalagon antramhur *)
lemma "todos (λy. y=x) (copia n x)"
by (induction n) simp_all

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 marfruman1 hugrubsan enrparalv benber chrgencar gleherlop
giafus1 pabbergue alikan antramhur aribatval *)
fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]" |
"amplia (x#xs) y = x # amplia xs y"

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

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan gleherlop enrparalv benber chrgencar giafus1
pabbergue alikan aribatval *)
lemma "amplia xs y = xs @ [y]"
apply (induction xs)
apply auto
done

(* pabalagon antramhur *)
lemma "amplia xs y = xs @ [y]"
by (induction xs) simp_all

(* marfruman1 *)
lemma "amplia xs y = xs @ [y]"
by (induction xs) auto

end
</source>

Relación 1

2019-03-06T18:48:35Z

Jalonso: Protegió «Relación 1» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

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

theory R1_Programacion_funcional_en_Isabelle
imports Main
begin

text {* ----------------------------------------------------------------
Ejercicio 1. Definir, por recursión, la función
longitud :: 'a list ⇒ nat
tal que (longitud xs) es la longitud de la listas xs. Por ejemplo,
longitud [a,b,c] = 3
------------------------------------------------------------------- *}

(* cammonagu pabalagon raffergon2 aribatval juacanrod josgomrom4
marfruman1 gleherlop benber alfmarcua enrparlav manperjim chrgencar
antramhur pabbergue alikan*)
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0 "
| "longitud (x#xs) = 1 + longitud xs "

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

(* hugrubsan giafus1 *)
fun longitud2 :: "'a list ⇒ nat" where
"longitud2 [] = 0 "
| "longitud2 xs = 1 + longitud2 (tl xs) "

value "longitud2 [a,b,c] = 3"

text {* ---------------------------------------------------------------
Ejercicio 2. Definir la función
fun intercambia :: 'a × 'b ⇒ 'b × 'a
tal que (intercambia p) es el par obtenido intercambiando las
componentes del par p. Por ejemplo,
intercambia (u,v) = (v,u)
------------------------------------------------------------------ *}

(* manperjim pabalagon cammonagu raffergon2 aribatval juacanrod
marfruman1 gleherlop benber hugrubsan alfmarcua enrparalv giafus1
chrgencar antramhur alikan pabbergue *)
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y, x)"

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

(* josgomrom4 *)
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 xs = (snd xs, fst xs) "

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

text {* ---------------------------------------------------------------
Ejercicio 3. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [a,d,c] = [c,d,a]
------------------------------------------------------------------ *}

(* pabalagon *)
fun aux :: "'a list ⇒ 'a list ⇒ 'a list" where
"aux [] a = a"
| "aux (x#xs) a = aux xs (x#a)"

fun inversa :: "'a list ⇒ 'a list" where
"inversa xs = aux xs []"

value "inversa [a,d,c] = [c,d,a]"

(* manperjim pabalagon raffergon2 cammonagu josgomrom4 marfruman1
gleherlop alfmarcua enrparalv chrgencar antramhur alikan pabbergue *)
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = []"
| "inversa2 (x#xs) = inversa2 xs @ [x]"

value "inversa2 [a,d,c] = [c,d,a]"

(* juacanrod hugrubsan giafus1 *)
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (xs) = inversa3(tl xs) @ [ hd (xs)]"

value "inversa3 [a,d,c] = [c,d,a]"

(* aribatval *)
fun inversa4 :: "'a list ⇒ 'a list" where
"inversa4 [] = []"
| "inversa4 xs = last xs # (inversa4 (butlast xs))"

value "inversa4 [a,d,c] = [c,d,a]"

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

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

value "inversa5 [a,d,c] = [c,d,a]"

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

(* pabalag aribatval antramhur *)
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]"

(* manperjim raffergon2 cammonagu josgomrom4 marfruman1 benber alfmarcua
gleherlop giafus1 chrgencar pabbergue alikan *)
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 0 x = [] "
| "repite2 n x = x # repite2 (n-1) x "

value "repite2 3 a = [a,a,a]"

(* juacanrod hugrubsan *)
fun repite3 :: "nat ⇒ 'a ⇒ 'a list" where
"repite3 0 a = []"
| "repite3 n a = [a] @ repite3 (n-1) a"

value "repite3 3 a = [a,a,a]"

(* enrparalv *)
fun repite4 :: "nat ⇒ 'a ⇒ 'a list" where
"repite4 n x = (if n = 0 then [] else repite4 (n-1) x @ [x])"

value "repite4 3 a = [a,a,a]"

text {* ---------------------------------------------------------------
Ejercicio 5. Definir la función
conc :: 'a list ⇒ 'a list ⇒ 'a list
tal que (conc xs ys) es la concatención de las listas xs e ys. Por
ejemplo,
conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 josgomrom4 aribatval gleherlop
chrgencar benber antramhur*)
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]"

(* cammonagu marfruman1 pabbergue *)
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 ys [] = ys" |
"conc2 xs (y#ys) = xs @y # ys"

value "conc2 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* juacanrod *)
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 [] ys = ys" |
"conc3 xs ys = [hd (xs)] @ conc3 (tl (xs)) ys"

value "conc3 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* hugrubsan enrparalv giafus1 alikan *)
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 xs ys = xs @ ys"

(* alfmarcua *)
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] ys = ys"
| "conc5 xs ys = conc5 (butlast xs) ((last xs)#ys)"

text {* ---------------------------------------------------------------
Ejercicio 6. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [a,c,d,b,e] = [a,c]
------------------------------------------------------------------ *}

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

value "coge 2 [a,c,d,b,e] = [a,c]"

(* manperjim cammonagu josgomrom4 marfruman1 benber alfmarcua chrgencar
gleherlop giafus1 pabbergue *)
fun coge2 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge2 0 xs = []" |
"coge2 n [] = []" |
"coge2 n (x#xs) = x # coge2 (n-1) xs"

value "coge2 2 [a,c,d,b,e] = [a,c]"

(* juacanrod *)
fun coge3 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge3 0 xs = []" |
"coge3 n xs = [hd (xs)] @ coge3 (n-1) (tl (xs))"

value "coge3 2 [a,c,d,b,e] = [a,c]"

(* aribatval hugrubsan *)
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []" |
"coge4 n [] = []" |
"coge4 n xs = (hd xs) # coge4 (n-1) (tl xs)"

value "coge4 2 [a,c,d,b,e] = [a,c]"

(* enrparalv *)
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 n [] = []"
| "coge5 n (x#xs) = (if (n=0) then [] else [x] @ coge5 (n-1) xs )"

value "coge5 2 [a,c,d,b,e] = [a,c]"

(* alikan *)
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 n [] = []"|
"coge6 n (x#xs) = (case n of 0 ⇒ [] | Suc n ⇒ x # coge6 n xs)"

value "coge6 2 [a,c,d,b,e] = [a,c]"

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
elimina :: nat ⇒ 'a list ⇒ 'a list
tal que (elimina n xs) es la lista obtenida eliminando los n primeros
elementos de xs. Por ejemplo,
elimina 2 [a,c,d,b,e] = [d,b,e]
------------------------------------------------------------------ *}

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

value "elimina 2 [a,c,d,b,e] = [d,b,e]"

(* manperjim raffergon2 cammonagu josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 pabbergue*)
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina2 0 xs = xs" |
"elimina2 n [] = []" |
"elimina2 n (x#xs) = elimina2 (n-1) xs"

value "elimina2 2 [a,c,d,b,e] = [d,b,e]"

(* juacanrod hugrubsan *)
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs" |
"elimina3 n xs = elimina3 (n-1) (tl xs)"

value "elimina3 2 [a,c,d,b,e] = [d,b,e]"

(* alikan *)
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 n [] = []"|
"elimina4 n (x#xs) = (case n of 0 ⇒ x#xs | Suc n ⇒ elimina4 n xs)"

value "elimina4 2 [a,c,d,b,e] = [d,b,e]"

text {* ---------------------------------------------------------------
Ejercicio 8. Definir la función
esVacia :: 'a list ⇒ bool
tal que (esVacia xs) se verifica si xs es la lista vacía. Por ejemplo,
esVacia [a] = False
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 josgomrom4 marfruman1 benber hugrubsan
alfmarcua enrparalv aribatval chrgencar giafus1 alikan pabbergue
antramhur *)
fun esVacia :: "'a list ⇒ bool" where
"esVacia [] = True" |
"esVacia xs = False"

value "esVacia [a] = False"

(* cammonagu juacanrod *)
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 xs = (longitud xs = 0)"

value "esVacia2 [a] = False"

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [a,c,b,e] = [e,b,c,a]
------------------------------------------------------------------ *}

(* manperjim pabalagon cammonagu josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 alikan pabbergue
antramhur *)
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]"

(* juacanrod *)
fun inversaAcAux2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux2 [] ys = ys" |
"inversaAcAux2 xs ys = inversaAcAux2 (tl xs) ([hd xs]) @ ys"

value "inversaAcAux2 [a,b,c] []"

fun inversaAc2 :: "'a list ⇒ 'a list" where
"inversaAc2 xs = inversaAcAux2 xs []"

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

(* hugrubsan *)
fun inversaAcAux3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux3 [] ys = ys"
|"inversaAcAux3 xs ys = inversaAcAux3 (tl xs) [(hd xs)] @ ys"

fun inversaAc3 :: "'a list ⇒ 'a list" where
"inversaAc3 xs = inversaAcAux3 (tl xs) [(hd xs)]"

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

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

(* manperjim pabalagon raffergon2 josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 pabbergue antramhur
alikan *)
fun sum :: "nat list ⇒ nat" where
"sum [] = 0" |
"sum (x#xs) = x + sum xs"

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

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

value "sum2 [3,2,5] = 10"

(* juacanrod hugrubsan *)
fun sum3 :: "nat list ⇒ nat" where
"sum3 [] = 0" |
"sum3 xs = (hd xs) + sum3 (tl xs)"

value "sum3 [3,2,5,1]"

text {* ---------------------------------------------------------------
Ejercicio 11. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3,2,5] = [6,4,10]
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 cammonagu josgomrom4 marfruman1 benber
alfmarcua aribatval gleherlop chrgencar giafus1 pabbergue antramhur *)
fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []" |
"map f (x#xs) = f x # map f xs"

value "map (λn. Suc n) [2,3,4,5]"

(* juacanrod *)
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []" |
"map2 f (x#xs) = [(f x)] @ map2 f xs"

value "map2 (λn. Suc n) [2,3,4,5]"

(* hugrubsan *)
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []" |
"map3 f xs = f (hd xs) # map3 f (tl xs)"

value "map3 (λn. Suc n) [2,3,4,5]"

end
</source>

Relación 7

2019-03-04T17:22:29Z

Jalonso:

Relación 8

2019-02-28T15:52:37Z

Jalonso:

<source lang="isabelle">
chapter {* R8: Gramáticas libres de contexto *}

theory R8_Gramaticas_libre_de_contexto
imports Main
begin

text {*
En esta relación se definen dos gramáticas libres de contexto y se
demuestra que son equivalentes. Además, se define por recursión una
función para reconocer las palabras de la gramática y se demuestra que
es correcta y completa. *}

text {*
---------------------------------------------------------------------
Ejercicio 1. Una gramática libre de contexto para las expresiones
parentizadas es
S ⟶ ε | '(' S ')' | SS
definir inductivamente la gramática S usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

datatype alfabeto = A | B

inductive_set S :: "alfabeto list set" where
S1: "[] ∈ S"
| S2: "w ∈ S ⟹ [A] @ w @ [B] ∈ S"
| S3: "v ∈ S ⟹ w ∈ S ⟹ v @ w ∈ S"

text {*
---------------------------------------------------------------------
Ejercicio 2. Otra gramática libre de contexto para las expresiones
parentizadas es
T ⟶ ε | T '(' T ')'
definir inductivamente la gramática T usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

inductive_set T :: "alfabeto list set" where
T1: "[] ∈ T"
| T2: "v ∈ T ⟹ w ∈ T ⟹ v @ [A] @ w @ [B] ∈ T"

text {*
---------------------------------------------------------------------
Ejercicio 3. Demostrar que T está contenido en S.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur *)
lemma T_en_S:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S"
proof (induction rule: T.induct)
show "[] ∈ S" by (rule S1)
next
fix v w
assume "w ∈ S"
hence "[A] @ w @ [B] ∈ S" by (rule S2)
moreover assume "v ∈ S"
ultimately show "v @ [A] @ w @ [B] ∈ S" using S3 by simp
qed
thus ?thesis using assms .
qed

(* cammonagu *)
declare S1 [iff] S2[intro!,simp]

(* cammonagu *)
declare T1 [iff]

(* cammonagu *)
lemma T2ImpS: "w ∈ T ⟹ w ∈ S"
apply (erule T.induct)
apply simp
apply (blast intro: S3)
done

(* cammonagu *)
lemma T_en_S1:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S" using assms by (rule T2ImpS)
thus ?thesis using assms .
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S está contenido en T.
------------------------------------------------------------------ *}

(* benber *)
lemma S_en_T:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w

have "[] ∈ T" by (rule T1)
moreover assume "w ∈ T"
ultimately have "[] @ [A] @ w @ [B] ∈ T" by (rule T2)
thus "[A] @ w @ [B] ∈ T" by simp
next
fix v w
assume "v ∈ T"
moreover assume "w ∈ T"
moreover have "⟦v ∈ T; w ∈ T⟧ ⟹ v @ w ∈ T" for v w
proof (induction "length w + length v"
arbitrary: w v
rule: less_induct)
case IH: less

show "v @ w ∈ T"
proof (cases w rule: T.cases)
show "w ∈ T" using `w ∈ T`.
next
assume "w = []"
thus "v @ w ∈ T" using `v ∈ T` by simp
next
fix w1 w2
assume "w1 ∈ T" and "w2 ∈ T"
assume "w = w1 @ [A] @ w2 @ [B]"
hence 1: "v @ w = v @ w1 @ [A] @ w2 @ [B]" by simp

have "length w1 < length w" using `w = w1 @ [A] @ w2 @ [B]`
by simp
hence "length v + length w1 < length v + length w" by simp
moreover note `v ∈ T`
moreover note `w1 ∈ T`
ultimately have "v @ w1 ∈ T" using IH by simp
moreover note `w2 ∈ T`
ultimately have "(v @ w1) @ [A] @ w2 @ [B] ∈ T" by (rule T2)
thus "v @ w ∈ T" using 1 by simp
qed
qed
ultimately show "v @ w ∈ T" by simp
qed

(* alfmarcua antramhur *)
lemma S_en_T_2:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w
assume "w ∈ T"
have "[] @ [A] @ w @ [B] ∈ T" using T1 `w ∈ T` by (rule T2)
then show "[A] @ w @ [B] ∈ T" by (simp only: List.append.append_Nil)
next
fix w v
assume "v ∈ T"
show "w ∈ T ⟹ v @ w ∈ T"
proof (induction rule: T.induct)
show "v @ [] ∈ T" using `v ∈ T`
by (simp only: List.append.right_neutral)
next
fix va w
have "v @ va ∈ T ⟹ w ∈ T ⟹ (v @ va) @ [A] @ w @ [B] ∈ T "
by (rule T2)
then show "v @ va ∈ T ⟹ w ∈ T ⟹ v @ va @ [A] @ w @ [B] ∈ T "
by (simp only: List.append_assoc)
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S y T son iguales.
------------------------------------------------------------------ *}

(* benber cammonagu antramhur *)
lemma S_igual_T:
"S = T"
using T_en_S S_en_T by auto

(* alfmarcua *)
lemma S_igual_T_2:
"S = T"
proof (rule equalityI)
show "S ⊆ T" using S_en_T by (rule subsetI)
next
show "T ⊆ S" using T_en_S by (rule subsetI)
qed

text {*
---------------------------------------------------------------------
Ejercicio 5. En lugar de una gramática, se puede usar el siguiente
procedimiento para determinar si la cadena es una sucesión de
paréntesis bien balanceada: se recorre la cadena de izquierda a
derecha contando cuántos paréntesis de necesitan para que esté bien
balanceada. Si el contador al final de la cadena es 0, la cadena está
bien balanceada.

Definir la función
balanceada :: alfabeto list ⇒ bool
tal que (balanceada w) se verifica si w está bien balanceada. Por
ejemplo,
balanceada [A,A,B,B] = True
balanceada [A,B,A,B] = True
balanceada [A,B,B,A] = False
Indicación: Definir balanceada usando la función auxiliar
balanceada_aux :: alfabeto list ⇒ nat ⇒ bool
tal que (balanceada_aux w 0) se verifica si w está bien balanceada.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur *)
(* balanceada_aux w n = True si y solo si ([A]*n) @ w es balanceada *)
fun balanceada_aux :: "alfabeto list ⇒ nat ⇒ bool" where
"balanceada_aux [] 0 = True"
| "balanceada_aux [] (Suc n) = False"
| "balanceada_aux (B#w) 0 = False"
| "balanceada_aux (B#w) (Suc n) = balanceada_aux w n"
| "balanceada_aux (A#w) n = balanceada_aux w (Suc n)"

fun balanceada :: "alfabeto list ⇒ bool" where
"balanceada w = balanceada_aux w 0"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que balanceada es un reconocedor correcto de la
gramática S; es decir,
w ∈ S ⟹ balanceada w
------------------------------------------------------------------ *}

(* benber *)
lemma balanceada_correcto_aux1:
"balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)"
proof (induction w arbitrary: n)
case Nil
assume "balanceada_aux [] n"
thus ?case by simp
next
case IS: (Cons x w)
show ?case
proof (cases x)
case A
note `balanceada_aux (x#w) n`
hence "balanceada_aux (A#w) n" using `x = A` by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@[B]) (Suc (Suc n))" using IS.IH by simp
hence "balanceada_aux ((A#w)@[B]) (Suc n)" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@[B]) (Suc m)" using IS.IH by simp
hence "balanceada_aux (w@[B]) n" using `n = Suc m` by simp
hence "balanceada_aux (B#(w@[B])) (Suc n)" by simp
thus ?thesis using `x = B` by simp
qed
qed
qed

lemma balanceada_correcto_aux2:
assumes "balanceada v"
shows "balanceada_aux w n ⟹ balanceada_aux (w @ v) n"
proof (induction w arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux.elims by auto
thus ?case using assms by simp
next
case IS: (Cons x w)
show "balanceada_aux ((x#w)@v) n"
proof (cases x)
case A
hence "balanceada_aux (A#w) n" using IS.prems by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@v) (Suc n)" using IS.IH by simp
hence "balanceada_aux (A#(w@v)) n" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@v) m" using IS.IH by simp
hence "balanceada_aux (B#(w@v)) (Suc m)" by simp
thus ?thesis using `x = B` `n = Suc m` by simp
qed
qed
qed

lemma balanceada_correcto:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada [] = balanceada_aux [] 0" by simp
also have "..." by simp
finally show ?case.
next
case S2
fix w
assume "balanceada w"
hence "balanceada_aux w 0" by simp
hence "balanceada_aux (w@[B]) 1" using balanceada_correcto_aux1
by simp
hence "balanceada_aux ([A] @ w @ [B]) 0" by simp
thus "balanceada ([A] @ w @ [B])" by simp
next
case S3
thus ?case using balanceada_correcto_aux2 by auto
qed

(* alfmarcua antramhur *)
lemma balanceada_correcto_aux3:
shows "balanceada_aux v m ⟹
balanceada_aux w n ⟹
balanceada_aux (v @ w) (m+n)"
proof (induction v arbitrary: n m)
case Nil
then show ?case
proof (cases m)
case 0
then have "balanceada_aux w (m + n)" using Nil.prems(2)
by (simp only:Groups.monoid_add_class.add.left_neutral)
then show ?thesis by (simp only:List.append.append_Nil)
next
case (Suc mm)
then have "False" using Nil.prems(1)
by (simp only: balanceada_aux.simps(2))
then show ?thesis ..
qed
next
case IS:(Cons a v)
show "balanceada_aux ((a # v) @ w) (m + n)"
proof (cases a)
define k :: nat where "k = m + 1"
case A
then have "balanceada_aux v k" using `k = m + 1` IS.prems(1)
by simp
then have "balanceada_aux (v @ w) (k + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (v @ w) (Suc(m + n))" using `k = m + 1`
by simp
then have "balanceada_aux (A # (v @ w)) (m + n)"
by (simp only: balanceada_aux.simps(5))
then show ?thesis using `a = A`
by (simp only:List.append.append_Cons)
next
case B
then show ?thesis
proof (cases m)
case 0
then have "False" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(3))
then show ?thesis ..
next
case (Suc mm)
hence "balanceada_aux v mm" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (v @ w) (mm + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (B # (v @ w)) (Suc (mm + n))"
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (B # (v @ w)) (m + n)"
using `m = Suc mm` by (simp only: Nat.plus_nat.add_Suc)
then show ?thesis using `a=B`
by (simp only:List.append.append_Cons)
qed
qed
qed

lemma balanceada_correcto_2:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then show ?case by (simp only: balanceada.simps)
next
case (S2 w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then have 2:"balanceada_aux (B#[]) (Suc 0)"
by (simp only: balanceada_aux.simps(4))
have "balanceada_aux w 0 ⟹
balanceada_aux [B] (Suc 0) ⟹
balanceada_aux (w @ [B]) (0+Suc 0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (w @ [B]) (Suc 0)" using 1 2
by (simp only:Groups.monoid_add_class.add.left_neutral)
then have "balanceada_aux (A # (w @ [B])) 0"
by (simp only: balanceada_aux.simps(5))
then have "balanceada_aux ([A] @ w @ [B]) 0"
by (simp only: List.append_Cons List.append_Nil)
then show ?case by (simp only: balanceada.simps)
next
case (S3 v w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have 2:"balanceada_aux v 0" using S3(3)
by (simp only: balanceada.simps)
have "balanceada_aux v 0 ⟹
balanceada_aux w 0 ⟹
balanceada_aux (v @ w) (0+0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (v @ w) 0" using 1 2
by (simp only:Groups.monoid_add_class.add.right_neutral)
then show ?case by (simp only: balanceada.simps)
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que balanceada es un reconocedor completo de
la gramática S; es decir,
balanceada w ⟹ w ∈ S
------------------------------------------------------------------ *}

(* benber *)
lemma balanceada_aux_unico:
"⟦balanceada_aux w k; balanceada_aux w l⟧ ⟹ k = l" for w k l
proof (induction w arbitrary: k l)
case Nil
hence "k = 0 ∧ l = 0" using balanceada_aux.elims by auto
thus ?case by simp
next
case IS: (Cons x w')
show ?case
proof (cases x)
case A
thus ?thesis using IS by auto
next
case B
show ?thesis
proof (cases k)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc k')
hence "balanceada_aux w' k'" using IS.prems `x = B` by simp

show ?thesis
proof (cases l)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc l')
hence "balanceada_aux w' l'" using IS.prems `x = B` by simp
thus ?thesis
using `balanceada_aux w' k'` IS.IH `k = Suc k'` `l = Suc l'`
by auto
qed
qed
qed
qed

lemma balanceada_completo_aux1:
"⟦balanceada (x # w @ [y]);
⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶ ¬ (balanceada v)⟧
⟹ x = A ∧ y = B ∧ balanceada w"
proof -
assume "balanceada (x # w @ [y])"
hence bal: "balanceada_aux ( x # w @ [y] ) 0" by simp

assume postfix_con: "⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶
¬ (balanceada v)"

have "x = A"
proof (rule ccontr)
assume "x ≠ A"
hence "x = B" using alfabeto.exhaust by blast
thus "False" using bal by simp
qed

have hl1: "balanceada_aux (w @ [y]) n ⟹ y = B" for w y n
proof (induction w arbitrary: n)
case IB: Nil
show "y = B"
proof (rule ccontr)
assume "y ≠ B"
hence "y = A" using alfabeto.exhaust by blast
thus "False" using IB by simp
qed
next
case IS: (Cons x w)
hence "balanceada_aux (x # w @ [y]) n" by simp
hence "∃m. balanceada_aux (w @ [y]) m" using balanceada_aux.elims(2)
by blast (* SH'd *)
thus "y = B" using IS.IH by auto
qed

have "y = B" using bal hl1[of "(x#w)"] by simp
hence "balanceada_aux (w @ [B]) 1" using bal `x = A` by simp

have hl2: "balanceada_aux (x#w) n ⟹ ∃m. balanceada_aux w m"
for x w n
proof (cases x)
case A
moreover assume "balanceada_aux (x#w) n"
ultimately show ?thesis by auto
next
case B
moreover assume "balanceada_aux (x#w) n"
ultimately have "balanceada_aux (B#w) n" by simp
thus ?thesis by (cases n) auto
qed

have "⟦balanceada_aux w n; u @ v = w⟧ ⟹ ∃ m. balanceada_aux v m"
for u v w n
proof (induction w arbitrary: u v n)
case Nil
hence "v = []" by simp
hence "balanceada_aux v 0" by simp
thus ?case ..
next
case IS: (Cons x w')
then obtain m where mDef: "balanceada_aux w' m" using hl2 by blast

show ?case
proof (cases u)
case Nil
hence "balanceada_aux v n" using IS by simp
thus ?thesis ..
next
case (Cons y u')
hence "w' = u' @ v" using IS.prems by simp
thus ?thesis using IS.IH mDef by simp
qed
qed
moreover have "balanceada_aux (w @ [B]) 1" using bal `x = A` `y = B`
by simp
ultimately have "u @ v = (w @ [B]) ⟹ ∃m. balanceada_aux v m"
for u v by auto
moreover {
fix u v
have 1: "⟦u' ≠ []; v ≠ []; u' @ v = (x # w @ [y])⟧ ⟹
¬(balanceada v)" for u'
using postfix_con by auto
have "⟦v ≠ []; (x#u) @ v = (x # w @ [y])⟧ ⟹ ¬(balanceada v)"
using 1[of "x#u"] by simp
hence "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹ ¬(balanceada_aux v 0)"
using `y = B` by simp
}
ultimately have hl3: "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹
∃m. balanceada_aux v (Suc m)" for u v
by (metis zero_induct) (* SH'd *)

have hl4: "⟦balanceada_aux (v @ [B]) (Suc n); ⋀s t. v = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)⟧
⟹ balanceada_aux v n" for v n
proof (induction v arbitrary: n)
case Nil
hence "balanceada_aux [B] (Suc n)" by simp
thus "balanceada_aux [] n" by simp
next
case IS: (Cons x v')

have "x#v' = [x] @ v'" by simp
then obtain m where mDef: "balanceada_aux (v' @ [B]) (Suc m)"
using IS.prems by blast
moreover have v'Postf: "⋀s t. v' = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)"
using IS.prems by auto
ultimately have "balanceada_aux v' m" using IS.IH by simp

show ?case
proof (cases x)
case A
hence "balanceada_aux ((A # v') @ [B]) (Suc n)" using IS.prems
by simp
hence "balanceada_aux (v' @ [B]) (Suc (Suc n))" by simp
hence "balanceada_aux v' (Suc n)" using IS.IH v'Postf by simp
thus ?thesis using `x = A` by simp
next
case B
hence "balanceada_aux ((B # v') @ [B]) (Suc n)" using IS.prems
by simp
hence 1: "balanceada_aux ( v' @ [B]) n" using IS.prems by simp

have "n = Suc m" using 1 mDef balanceada_aux_unico by simp
thus "balanceada_aux (x # v') n"
using `balanceada_aux v' m` `x = B` by simp
qed
qed
moreover note `balanceada_aux (w @ [B]) 1`
moreover have "w = s @ t ⟹ ∃m. balanceada_aux (t @ [B]) (Suc m)"
for s t using hl3 by simp
ultimately have "balanceada_aux w 0" by simp
thus "x = A ∧ y = B ∧ balanceada w" using `x = A` `y = B`by simp
qed

lemma balanceada_completo_aux2:
assumes "balanceada (u @ v)" and "¬ balanceada u"
shows "¬ balanceada v"
proof -
have "⟦balanceada_aux (u @ v) n; balanceada v⟧ ⟹ balanceada_aux u n"
for n
proof (induction u arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux_unico by simp
thus ?case by simp
next
case IS: (Cons x u')
show ?case
proof (cases x)
case A
hence "balanceada_aux (A # u' @ v) n" using IS.prems by simp
hence "balanceada_aux (u' @ v) (Suc n)" by simp
hence "balanceada_aux u' (Suc n)" using `balanceada v` IS.IH
by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B # u' @ v) n" using IS.prems by simp
then obtain m where "Suc m = n" by (cases n) auto
hence "balanceada_aux (B # u' @ v) (Suc m)" using 1 by simp
hence "balanceada_aux u' m" using `balanceada v` IS.IH by simp
hence "balanceada_aux (B # u') n" using `Suc m = n` by auto
thus ?thesis using `x = B` by simp
qed
qed
thus ?thesis using assms by auto
qed

lemma balanceada_completo:
assumes "balanceada w"
shows "w ∈ S"
proof -
have "balanceada w ⟹ w ∈ S"
proof (induction "length w" arbitrary: w rule: less_induct)
case IS: less

show ?case
proof (cases w)
case Nil
thus ?thesis using S1 by simp
next
case (Cons x w')
show ?thesis
proof (cases w')
case Nil
hence "¬ balanceada (x#w')" by (cases x) auto
hence "False" using `w = x # w'`IS.prems by simp
thus ?thesis ..
next
case (Cons y w'')
show ?thesis
proof cases
assume "∃u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
then obtain u v where "w = u @ v" and
"u ≠ []" and
"v ≠ []" and
"balanceada u"
and "balanceada v" by blast

have "u ∈ S" using `w = u @ v` `v ≠ []` `balanceada u` IS
by simp
moreover have "v ∈ S"
using `w = u @ v` `u ≠ []` `balanceada v` IS by simp
ultimately show "w ∈ S" using S3 `w = u @ v` by simp
next
assume "∄u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
hence 1: "⟦u @ v = w; u ≠ []; v ≠ []; balanceada u⟧ ⟹
¬ balanceada v" for u v by auto

have "w = x # y # w''" using `w = x # w'` `w' = y # w''`
by simp
moreover have "∃ u z. y # w'' = u @ [z]"
proof -
have "∃ u y. (x :: alfabeto) # v = u @ [y]" for x v
proof (induction v arbitrary: x)
case Nil
have "x # [] = [] @ [x]" by simp
thus ?case by simp
next
case IS: (Cons z v')
then obtain u' y' where "z # v' = u' @ [y']" by blast
hence "x # z # v' = x # u' @ [y']" using IS by simp
thus ?case by simp
qed
thus ?thesis by simp
qed
ultimately have "∃ u z. w = x # u @ [z]" by auto
then obtain u z where "w = x # u @ [z]" by blast
hence "balanceada (x # u @ [z])" using `balanceada w` by simp
moreover have "⟦s ≠ []; t ≠ []; s @ t = x # u @ [z]⟧ ⟹
¬ balanceada t" for s t
proof (cases "balanceada s")
case True
moreover assume "s ≠ []"
moreover assume "t ≠ []"
moreover assume "s @ t = x # u @ [z]"
ultimately show ?thesis using 1 `w = x # u @ [z]` by auto
next
case False

assume "s @ t = x # u @ [z]"
hence "x # u @ [z] = s @ t" ..
thus ?thesis
using balanceada_completo_aux2
`balanceada w`
`¬ balanceada s`
`w = x # u @ [z]`
by simp
qed
ultimately have "x = A" and "z = B" and "balanceada u"
using balanceada_completo_aux1[of x u z] by auto
moreover have "u ∈ S"
using `w = x # u @ [z]` IS `balanceada u` by simp
hence "x # u @ [z] ∈ S" using S2 `u ∈ S` `x = A` `z = B`
by simp
thus "w ∈ S" using `w = x # u @ [z]` by simp
qed
qed
qed
qed
thus ?thesis using assms .
qed

end
</source>

Relación 8

2019-02-28T15:52:24Z

Jalonso:

<source lang="isabelle">
chapter {* R8: Gramáticas libres de contexto *}

theory R8_Gramaticas_libre_de_contexto_alu
imports Main
begin

text {*
En esta relación se definen dos gramáticas libres de contexto y se
demuestra que son equivalentes. Además, se define por recursión una
función para reconocer las palabras de la gramática y se demuestra que
es correcta y completa. *}

text {*
---------------------------------------------------------------------
Ejercicio 1. Una gramática libre de contexto para las expresiones
parentizadas es
S ⟶ ε | '(' S ')' | SS
definir inductivamente la gramática S usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

datatype alfabeto = A | B

inductive_set S :: "alfabeto list set" where
S1: "[] ∈ S"
| S2: "w ∈ S ⟹ [A] @ w @ [B] ∈ S"
| S3: "v ∈ S ⟹ w ∈ S ⟹ v @ w ∈ S"

text {*
---------------------------------------------------------------------
Ejercicio 2. Otra gramática libre de contexto para las expresiones
parentizadas es
T ⟶ ε | T '(' T ')'
definir inductivamente la gramática T usando A y B para '(' y ')',
respectivamente.
------------------------------------------------------------------ *}

inductive_set T :: "alfabeto list set" where
T1: "[] ∈ T"
| T2: "v ∈ T ⟹ w ∈ T ⟹ v @ [A] @ w @ [B] ∈ T"

text {*
---------------------------------------------------------------------
Ejercicio 3. Demostrar que T está contenido en S.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur *)
lemma T_en_S:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S"
proof (induction rule: T.induct)
show "[] ∈ S" by (rule S1)
next
fix v w
assume "w ∈ S"
hence "[A] @ w @ [B] ∈ S" by (rule S2)
moreover assume "v ∈ S"
ultimately show "v @ [A] @ w @ [B] ∈ S" using S3 by simp
qed
thus ?thesis using assms .
qed

(* cammonagu *)
declare S1 [iff] S2[intro!,simp]

(* cammonagu *)
declare T1 [iff]

(* cammonagu *)
lemma T2ImpS: "w ∈ T ⟹ w ∈ S"
apply (erule T.induct)
apply simp
apply (blast intro: S3)
done

(* cammonagu *)
lemma T_en_S1:
assumes "w ∈ T"
shows "w ∈ S"
proof -
have "w ∈ T ⟹ w ∈ S" using assms by (rule T2ImpS)
thus ?thesis using assms .
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S está contenido en T.
------------------------------------------------------------------ *}

(* benber *)
lemma S_en_T:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w

have "[] ∈ T" by (rule T1)
moreover assume "w ∈ T"
ultimately have "[] @ [A] @ w @ [B] ∈ T" by (rule T2)
thus "[A] @ w @ [B] ∈ T" by simp
next
fix v w
assume "v ∈ T"
moreover assume "w ∈ T"
moreover have "⟦v ∈ T; w ∈ T⟧ ⟹ v @ w ∈ T" for v w
proof (induction "length w + length v"
arbitrary: w v
rule: less_induct)
case IH: less

show "v @ w ∈ T"
proof (cases w rule: T.cases)
show "w ∈ T" using `w ∈ T`.
next
assume "w = []"
thus "v @ w ∈ T" using `v ∈ T` by simp
next
fix w1 w2
assume "w1 ∈ T" and "w2 ∈ T"
assume "w = w1 @ [A] @ w2 @ [B]"
hence 1: "v @ w = v @ w1 @ [A] @ w2 @ [B]" by simp

have "length w1 < length w" using `w = w1 @ [A] @ w2 @ [B]`
by simp
hence "length v + length w1 < length v + length w" by simp
moreover note `v ∈ T`
moreover note `w1 ∈ T`
ultimately have "v @ w1 ∈ T" using IH by simp
moreover note `w2 ∈ T`
ultimately have "(v @ w1) @ [A] @ w2 @ [B] ∈ T" by (rule T2)
thus "v @ w ∈ T" using 1 by simp
qed
qed
ultimately show "v @ w ∈ T" by simp
qed

(* alfmarcua antramhur *)
lemma S_en_T_2:
"w ∈ S ⟹ w ∈ T"
proof (induction rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w
assume "w ∈ T"
have "[] @ [A] @ w @ [B] ∈ T" using T1 `w ∈ T` by (rule T2)
then show "[A] @ w @ [B] ∈ T" by (simp only: List.append.append_Nil)
next
fix w v
assume "v ∈ T"
show "w ∈ T ⟹ v @ w ∈ T"
proof (induction rule: T.induct)
show "v @ [] ∈ T" using `v ∈ T`
by (simp only: List.append.right_neutral)
next
fix va w
have "v @ va ∈ T ⟹ w ∈ T ⟹ (v @ va) @ [A] @ w @ [B] ∈ T "
by (rule T2)
then show "v @ va ∈ T ⟹ w ∈ T ⟹ v @ va @ [A] @ w @ [B] ∈ T "
by (simp only: List.append_assoc)
qed
qed

text {*
---------------------------------------------------------------------
Ejercicio 4. Demostrar que S y T son iguales.
------------------------------------------------------------------ *}

(* benber cammonagu antramhur *)
lemma S_igual_T:
"S = T"
using T_en_S S_en_T by auto

(* alfmarcua *)
lemma S_igual_T_2:
"S = T"
proof (rule equalityI)
show "S ⊆ T" using S_en_T by (rule subsetI)
next
show "T ⊆ S" using T_en_S by (rule subsetI)
qed

text {*
---------------------------------------------------------------------
Ejercicio 5. En lugar de una gramática, se puede usar el siguiente
procedimiento para determinar si la cadena es una sucesión de
paréntesis bien balanceada: se recorre la cadena de izquierda a
derecha contando cuántos paréntesis de necesitan para que esté bien
balanceada. Si el contador al final de la cadena es 0, la cadena está
bien balanceada.

Definir la función
balanceada :: alfabeto list ⇒ bool
tal que (balanceada w) se verifica si w está bien balanceada. Por
ejemplo,
balanceada [A,A,B,B] = True
balanceada [A,B,A,B] = True
balanceada [A,B,B,A] = False
Indicación: Definir balanceada usando la función auxiliar
balanceada_aux :: alfabeto list ⇒ nat ⇒ bool
tal que (balanceada_aux w 0) se verifica si w está bien balanceada.
------------------------------------------------------------------ *}

(* benber alfmarcua antramhur *)
(* balanceada_aux w n = True si y solo si ([A]*n) @ w es balanceada *)
fun balanceada_aux :: "alfabeto list ⇒ nat ⇒ bool" where
"balanceada_aux [] 0 = True"
| "balanceada_aux [] (Suc n) = False"
| "balanceada_aux (B#w) 0 = False"
| "balanceada_aux (B#w) (Suc n) = balanceada_aux w n"
| "balanceada_aux (A#w) n = balanceada_aux w (Suc n)"

fun balanceada :: "alfabeto list ⇒ bool" where
"balanceada w = balanceada_aux w 0"

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar que balanceada es un reconocedor correcto de la
gramática S; es decir,
w ∈ S ⟹ balanceada w
------------------------------------------------------------------ *}

(* benber *)
lemma balanceada_correcto_aux1:
"balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)"
proof (induction w arbitrary: n)
case Nil
assume "balanceada_aux [] n"
thus ?case by simp
next
case IS: (Cons x w)
show ?case
proof (cases x)
case A
note `balanceada_aux (x#w) n`
hence "balanceada_aux (A#w) n" using `x = A` by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@[B]) (Suc (Suc n))" using IS.IH by simp
hence "balanceada_aux ((A#w)@[B]) (Suc n)" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@[B]) (Suc m)" using IS.IH by simp
hence "balanceada_aux (w@[B]) n" using `n = Suc m` by simp
hence "balanceada_aux (B#(w@[B])) (Suc n)" by simp
thus ?thesis using `x = B` by simp
qed
qed
qed

lemma balanceada_correcto_aux2:
assumes "balanceada v"
shows "balanceada_aux w n ⟹ balanceada_aux (w @ v) n"
proof (induction w arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux.elims by auto
thus ?case using assms by simp
next
case IS: (Cons x w)
show "balanceada_aux ((x#w)@v) n"
proof (cases x)
case A
hence "balanceada_aux (A#w) n" using IS.prems by simp
hence "balanceada_aux w (Suc n)" by simp
hence "balanceada_aux (w@v) (Suc n)" using IS.IH by simp
hence "balanceada_aux (A#(w@v)) n" by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B#w) n" using IS.prems by simp

show ?thesis
proof (cases n)
case 0
hence "balanceada_aux (B#w) 0" using 1 by simp
hence "False" by simp
thus ?thesis ..
next
case (Suc m)
hence "balanceada_aux (B#w) (Suc m)" using 1 by simp
hence "balanceada_aux w m" by simp
hence "balanceada_aux (w@v) m" using IS.IH by simp
hence "balanceada_aux (B#(w@v)) (Suc m)" by simp
thus ?thesis using `x = B` `n = Suc m` by simp
qed
qed
qed

lemma balanceada_correcto:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada [] = balanceada_aux [] 0" by simp
also have "..." by simp
finally show ?case.
next
case S2
fix w
assume "balanceada w"
hence "balanceada_aux w 0" by simp
hence "balanceada_aux (w@[B]) 1" using balanceada_correcto_aux1
by simp
hence "balanceada_aux ([A] @ w @ [B]) 0" by simp
thus "balanceada ([A] @ w @ [B])" by simp
next
case S3
thus ?case using balanceada_correcto_aux2 by auto
qed

(* alfmarcua antramhur *)
lemma balanceada_correcto_aux3:
shows "balanceada_aux v m ⟹
balanceada_aux w n ⟹
balanceada_aux (v @ w) (m+n)"
proof (induction v arbitrary: n m)
case Nil
then show ?case
proof (cases m)
case 0
then have "balanceada_aux w (m + n)" using Nil.prems(2)
by (simp only:Groups.monoid_add_class.add.left_neutral)
then show ?thesis by (simp only:List.append.append_Nil)
next
case (Suc mm)
then have "False" using Nil.prems(1)
by (simp only: balanceada_aux.simps(2))
then show ?thesis ..
qed
next
case IS:(Cons a v)
show "balanceada_aux ((a # v) @ w) (m + n)"
proof (cases a)
define k :: nat where "k = m + 1"
case A
then have "balanceada_aux v k" using `k = m + 1` IS.prems(1)
by simp
then have "balanceada_aux (v @ w) (k + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (v @ w) (Suc(m + n))" using `k = m + 1`
by simp
then have "balanceada_aux (A # (v @ w)) (m + n)"
by (simp only: balanceada_aux.simps(5))
then show ?thesis using `a = A`
by (simp only:List.append.append_Cons)
next
case B
then show ?thesis
proof (cases m)
case 0
then have "False" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(3))
then show ?thesis ..
next
case (Suc mm)
hence "balanceada_aux v mm" using IS.prems(1) `a = B`
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (v @ w) (mm + n)" using IS.prems(2)
by (rule IS.IH)
then have "balanceada_aux (B # (v @ w)) (Suc (mm + n))"
by (simp only: balanceada_aux.simps(4))
then have "balanceada_aux (B # (v @ w)) (m + n)"
using `m = Suc mm` by (simp only: Nat.plus_nat.add_Suc)
then show ?thesis using `a=B`
by (simp only:List.append.append_Cons)
qed
qed
qed

lemma balanceada_correcto_2:
"w ∈ S ⟹ balanceada w"
proof (induction rule: S.induct)
case S1
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then show ?case by (simp only: balanceada.simps)
next
case (S2 w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have "balanceada_aux [] 0" by (simp only: balanceada_aux.simps(1))
then have 2:"balanceada_aux (B#[]) (Suc 0)"
by (simp only: balanceada_aux.simps(4))
have "balanceada_aux w 0 ⟹
balanceada_aux [B] (Suc 0) ⟹
balanceada_aux (w @ [B]) (0+Suc 0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (w @ [B]) (Suc 0)" using 1 2
by (simp only:Groups.monoid_add_class.add.left_neutral)
then have "balanceada_aux (A # (w @ [B])) 0"
by (simp only: balanceada_aux.simps(5))
then have "balanceada_aux ([A] @ w @ [B]) 0"
by (simp only: List.append_Cons List.append_Nil)
then show ?case by (simp only: balanceada.simps)
next
case (S3 v w)
then have 1:"balanceada_aux w 0" by (simp only: balanceada.simps)
have 2:"balanceada_aux v 0" using S3(3)
by (simp only: balanceada.simps)
have "balanceada_aux v 0 ⟹
balanceada_aux w 0 ⟹
balanceada_aux (v @ w) (0+0)"
by (rule balanceada_correcto_aux3)
then have "balanceada_aux (v @ w) 0" using 1 2
by (simp only:Groups.monoid_add_class.add.right_neutral)
then show ?case by (simp only: balanceada.simps)
qed

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar que balanceada es un reconocedor completo de
la gramática S; es decir,
balanceada w ⟹ w ∈ S
------------------------------------------------------------------ *}

(* benber *)
lemma balanceada_aux_unico:
"⟦balanceada_aux w k; balanceada_aux w l⟧ ⟹ k = l" for w k l
proof (induction w arbitrary: k l)
case Nil
hence "k = 0 ∧ l = 0" using balanceada_aux.elims by auto
thus ?case by simp
next
case IS: (Cons x w')
show ?case
proof (cases x)
case A
thus ?thesis using IS by auto
next
case B
show ?thesis
proof (cases k)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc k')
hence "balanceada_aux w' k'" using IS.prems `x = B` by simp

show ?thesis
proof (cases l)
case 0
hence "False" using IS.prems `x = B` by simp
thus ?thesis ..
next
case (Suc l')
hence "balanceada_aux w' l'" using IS.prems `x = B` by simp
thus ?thesis
using `balanceada_aux w' k'` IS.IH `k = Suc k'` `l = Suc l'`
by auto
qed
qed
qed
qed

lemma balanceada_completo_aux1:
"⟦balanceada (x # w @ [y]);
⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶ ¬ (balanceada v)⟧
⟹ x = A ∧ y = B ∧ balanceada w"
proof -
assume "balanceada (x # w @ [y])"
hence bal: "balanceada_aux ( x # w @ [y] ) 0" by simp

assume postfix_con: "⋀u v. u ≠ [] ∧ v ≠ [] ∧ u @ v = x # w @ [y] ⟶
¬ (balanceada v)"

have "x = A"
proof (rule ccontr)
assume "x ≠ A"
hence "x = B" using alfabeto.exhaust by blast
thus "False" using bal by simp
qed

have hl1: "balanceada_aux (w @ [y]) n ⟹ y = B" for w y n
proof (induction w arbitrary: n)
case IB: Nil
show "y = B"
proof (rule ccontr)
assume "y ≠ B"
hence "y = A" using alfabeto.exhaust by blast
thus "False" using IB by simp
qed
next
case IS: (Cons x w)
hence "balanceada_aux (x # w @ [y]) n" by simp
hence "∃m. balanceada_aux (w @ [y]) m" using balanceada_aux.elims(2)
by blast (* SH'd *)
thus "y = B" using IS.IH by auto
qed

have "y = B" using bal hl1[of "(x#w)"] by simp
hence "balanceada_aux (w @ [B]) 1" using bal `x = A` by simp

have hl2: "balanceada_aux (x#w) n ⟹ ∃m. balanceada_aux w m"
for x w n
proof (cases x)
case A
moreover assume "balanceada_aux (x#w) n"
ultimately show ?thesis by auto
next
case B
moreover assume "balanceada_aux (x#w) n"
ultimately have "balanceada_aux (B#w) n" by simp
thus ?thesis by (cases n) auto
qed

have "⟦balanceada_aux w n; u @ v = w⟧ ⟹ ∃ m. balanceada_aux v m"
for u v w n
proof (induction w arbitrary: u v n)
case Nil
hence "v = []" by simp
hence "balanceada_aux v 0" by simp
thus ?case ..
next
case IS: (Cons x w')
then obtain m where mDef: "balanceada_aux w' m" using hl2 by blast

show ?case
proof (cases u)
case Nil
hence "balanceada_aux v n" using IS by simp
thus ?thesis ..
next
case (Cons y u')
hence "w' = u' @ v" using IS.prems by simp
thus ?thesis using IS.IH mDef by simp
qed
qed
moreover have "balanceada_aux (w @ [B]) 1" using bal `x = A` `y = B`
by simp
ultimately have "u @ v = (w @ [B]) ⟹ ∃m. balanceada_aux v m"
for u v by auto
moreover {
fix u v
have 1: "⟦u' ≠ []; v ≠ []; u' @ v = (x # w @ [y])⟧ ⟹
¬(balanceada v)" for u'
using postfix_con by auto
have "⟦v ≠ []; (x#u) @ v = (x # w @ [y])⟧ ⟹ ¬(balanceada v)"
using 1[of "x#u"] by simp
hence "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹ ¬(balanceada_aux v 0)"
using `y = B` by simp
}
ultimately have hl3: "⟦v ≠ []; u @ v = (w @ [B])⟧ ⟹
∃m. balanceada_aux v (Suc m)" for u v
by (metis zero_induct) (* SH'd *)

have hl4: "⟦balanceada_aux (v @ [B]) (Suc n); ⋀s t. v = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)⟧
⟹ balanceada_aux v n" for v n
proof (induction v arbitrary: n)
case Nil
hence "balanceada_aux [B] (Suc n)" by simp
thus "balanceada_aux [] n" by simp
next
case IS: (Cons x v')

have "x#v' = [x] @ v'" by simp
then obtain m where mDef: "balanceada_aux (v' @ [B]) (Suc m)"
using IS.prems by blast
moreover have v'Postf: "⋀s t. v' = s @ t ⟹
∃m. balanceada_aux (t @ [B]) (Suc m)"
using IS.prems by auto
ultimately have "balanceada_aux v' m" using IS.IH by simp

show ?case
proof (cases x)
case A
hence "balanceada_aux ((A # v') @ [B]) (Suc n)" using IS.prems
by simp
hence "balanceada_aux (v' @ [B]) (Suc (Suc n))" by simp
hence "balanceada_aux v' (Suc n)" using IS.IH v'Postf by simp
thus ?thesis using `x = A` by simp
next
case B
hence "balanceada_aux ((B # v') @ [B]) (Suc n)" using IS.prems
by simp
hence 1: "balanceada_aux ( v' @ [B]) n" using IS.prems by simp

have "n = Suc m" using 1 mDef balanceada_aux_unico by simp
thus "balanceada_aux (x # v') n"
using `balanceada_aux v' m` `x = B` by simp
qed
qed
moreover note `balanceada_aux (w @ [B]) 1`
moreover have "w = s @ t ⟹ ∃m. balanceada_aux (t @ [B]) (Suc m)"
for s t using hl3 by simp
ultimately have "balanceada_aux w 0" by simp
thus "x = A ∧ y = B ∧ balanceada w" using `x = A` `y = B`by simp
qed

lemma balanceada_completo_aux2:
assumes "balanceada (u @ v)" and "¬ balanceada u"
shows "¬ balanceada v"
proof -
have "⟦balanceada_aux (u @ v) n; balanceada v⟧ ⟹ balanceada_aux u n"
for n
proof (induction u arbitrary: n)
case Nil
hence "n = 0" using balanceada_aux_unico by simp
thus ?case by simp
next
case IS: (Cons x u')
show ?case
proof (cases x)
case A
hence "balanceada_aux (A # u' @ v) n" using IS.prems by simp
hence "balanceada_aux (u' @ v) (Suc n)" by simp
hence "balanceada_aux u' (Suc n)" using `balanceada v` IS.IH
by simp
thus ?thesis using `x = A` by simp
next
case B
hence 1: "balanceada_aux (B # u' @ v) n" using IS.prems by simp
then obtain m where "Suc m = n" by (cases n) auto
hence "balanceada_aux (B # u' @ v) (Suc m)" using 1 by simp
hence "balanceada_aux u' m" using `balanceada v` IS.IH by simp
hence "balanceada_aux (B # u') n" using `Suc m = n` by auto
thus ?thesis using `x = B` by simp
qed
qed
thus ?thesis using assms by auto
qed

lemma balanceada_completo:
assumes "balanceada w"
shows "w ∈ S"
proof -
have "balanceada w ⟹ w ∈ S"
proof (induction "length w" arbitrary: w rule: less_induct)
case IS: less

show ?case
proof (cases w)
case Nil
thus ?thesis using S1 by simp
next
case (Cons x w')
show ?thesis
proof (cases w')
case Nil
hence "¬ balanceada (x#w')" by (cases x) auto
hence "False" using `w = x # w'`IS.prems by simp
thus ?thesis ..
next
case (Cons y w'')
show ?thesis
proof cases
assume "∃u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
then obtain u v where "w = u @ v" and
"u ≠ []" and
"v ≠ []" and
"balanceada u"
and "balanceada v" by blast

have "u ∈ S" using `w = u @ v` `v ≠ []` `balanceada u` IS
by simp
moreover have "v ∈ S"
using `w = u @ v` `u ≠ []` `balanceada v` IS by simp
ultimately show "w ∈ S" using S3 `w = u @ v` by simp
next
assume "∄u v. w = u @ v ∧ u ≠ [] ∧ v ≠ [] ∧
balanceada u ∧ balanceada v"
hence 1: "⟦u @ v = w; u ≠ []; v ≠ []; balanceada u⟧ ⟹
¬ balanceada v" for u v by auto

have "w = x # y # w''" using `w = x # w'` `w' = y # w''`
by simp
moreover have "∃ u z. y # w'' = u @ [z]"
proof -
have "∃ u y. (x :: alfabeto) # v = u @ [y]" for x v
proof (induction v arbitrary: x)
case Nil
have "x # [] = [] @ [x]" by simp
thus ?case by simp
next
case IS: (Cons z v')
then obtain u' y' where "z # v' = u' @ [y']" by blast
hence "x # z # v' = x # u' @ [y']" using IS by simp
thus ?case by simp
qed
thus ?thesis by simp
qed
ultimately have "∃ u z. w = x # u @ [z]" by auto
then obtain u z where "w = x # u @ [z]" by blast
hence "balanceada (x # u @ [z])" using `balanceada w` by simp
moreover have "⟦s ≠ []; t ≠ []; s @ t = x # u @ [z]⟧ ⟹
¬ balanceada t" for s t
proof (cases "balanceada s")
case True
moreover assume "s ≠ []"
moreover assume "t ≠ []"
moreover assume "s @ t = x # u @ [z]"
ultimately show ?thesis using 1 `w = x # u @ [z]` by auto
next
case False

assume "s @ t = x # u @ [z]"
hence "x # u @ [z] = s @ t" ..
thus ?thesis
using balanceada_completo_aux2
`balanceada w`
`¬ balanceada s`
`w = x # u @ [z]`
by simp
qed
ultimately have "x = A" and "z = B" and "balanceada u"
using balanceada_completo_aux1[of x u z] by auto
moreover have "u ∈ S"
using `w = x # u @ [z]` IS `balanceada u` by simp
hence "x # u @ [z] ∈ S" using S2 `u ∈ S` `x = A` `z = B`
by simp
thus "w ∈ S" using `w = x # u @ [z]` by simp
qed
qed
qed
qed
thus ?thesis using assms .
qed

end
</source>

Relación 7

2019-02-28T13:13:59Z

Jalonso:

<source lang="isabelle">
chapter {* R6: Deducción natural proposicional *}

theory R6_Deduccion_natural_proposicional
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es demostrar cada uno de los ejercicios
usando sólo las reglas básicas de deducción natural de la lógica
proposicional (sin usar el método auto).

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

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

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

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

section {* Implicaciones *}

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

(* pabalagon manperjim josgomrom4 cammonagu raffergon2 chrgencar
gleherlop giafus1 marfruman1 enrparalv pabbergue antramhur alikan
juacanrod hugrubsan *)
lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
proof -
show "q" using 1 2 by (rule mp)
qed

(* benber alfmarcua *)
lemma ejercicio_1_1:
assumes "p ⟶ q"
"p"
shows "q"
using assms by (rule mp)

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_2:
assumes 1: "p ⟶ q" and
2: "q ⟶ r" and
3: "p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed

(* benber *)
lemma ejercicio_2_1:
assumes "p ⟶ q"
"q ⟶ r"
"p"
shows "r"
proof -
have "q" using `p ⟶ q` `p` by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_3:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p ⟶ q" and
3: "p"
shows "r"
proof -
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_3_1:
assumes "p ⟶ (q ⟶ r)"
"p ⟶ q"
"p"
shows "r"
proof -
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu chrgencar raffergon2
gleherlop giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_4:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof -
{ assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "r" using 2 4 by (rule mp)}
thus "p ⟶ r" by (rule impI)
qed

(* benber *)
lemma ejercicio_4_1:
assumes "p ⟶ q"
"q ⟶ r"
shows "p ⟶ r"
proof
assume p
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim raffergon2 giafus1 gleherlop marfruman1 alfmarcua
enrparalv chrgencar pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_5:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
show "r" using 4 2 by (rule mp)
qed
qed

(* benber josgomrom4 juacanrod cammonagu *)
lemma ejercicio_5_1:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof
assume "q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
thus "r" using `q` by (rule mp)
qed
qed

(* pabalagon *)
lemma ejercicio_5_2:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{ assume 2: "q"
{ assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "r" using 4 2 by (rule mp)}
hence "p ⟶ r" by (rule impI)
}
thus "q ⟶ (p ⟶ r)" by (rule impI)
qed

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

(* pabalagon manperjim cammonagu chrgencar raffergon2 gleherlop giafus1
marfruman1 alfmarcua enrparalv pabbergue antramhur alikan juacanrod
hugrubsan *)
lemma ejercicio_6:
assumes 1: "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed

(* benber josgomrom4 *)
lemma ejercicio_6_1:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ⟶ q` `p` have "q" by (rule mp)
ultimately show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 gleherlop
marfruman1 enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_7:
assumes 1: "p"
shows "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed

(* benber cammonagu juacanrod chrgencar *)
lemma ejercicio_7_1:
assumes "p"
shows "q ⟶ p"
proof
show "p" using `p` .
qed

(* alfmarcua *)
lemma ejercicio_7_2:
assumes "p"
shows "q ⟶ p"
using assms by (rule impI)

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 marfruman1
enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_8:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed
qed

(* benber cammonagu gleherlop chrgencar juacanrod alfmarcua *)
lemma ejercicio_8_1:
"p ⟶ (q ⟶ p)"
using ejercicio_7_1 by (rule impI)

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

(* pabalagon manperjim raffergon2 giafus1 marfruman1 alfmarcua enrparalv
gleherlop antramhur alikan hugrubsan *)
lemma ejercicio_9:
assumes 1: "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q ⟶ r"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu chrgencar juacanrod pabbergue *)
lemma ejercicio_9_1:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof
assume "q ⟶ r"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop alfmarcua
enrparalv pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_10:
assumes 1: "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof (rule impI)
assume 2: "r"
show "q ⟶ (p ⟶ s)"
proof (rule impI)
assume 3: "q"
show "p ⟶ s"
proof (rule impI)
assume 4: "p"
have 5: "q ⟶ (r ⟶ s)" using 1 4 by (rule mp)
have 6: "r ⟶ s" using 5 3 by (rule mp)
show "s" using 6 2 by (rule mp)
qed
qed
qed

(* benber josgomrom4 cammonagu chrgencar giafus1 *)
lemma ejercicio_10_1:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof
assume "r"
show "q ⟶ (p ⟶ s)"
proof
assume "q"
show "p ⟶ s"
proof
assume "p"
with `p ⟶ (q ⟶ (r ⟶ s))`
have "q ⟶ (r ⟶ s)" by (rule mp)
hence "r ⟶ s" using `q` by (rule mp)
thus "s" using `r` by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim josgomrom4 gleherlop cammonagu giafus1 alfmarcua
chrgencar pabbergue alikan juacanrod hugrubsan *)
lemma ejercicio_11:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)" using 1 ejercicio_6 by simp
qed

(* pabalagon raffergon2 marfruman1 enrparalv antramhur *)
lemma ejercicio_11_2:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed
qed

(* benber *)
lemma ejercicio_11_1:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume p
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show r by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop enrparalv
pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_12:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ⟶ q"
proof (rule impI)
assume 5: "p"
show "q" using 3 by this
qed
show "r" using 1 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu giafus1 alfmarcua chrgencar *)
lemma ejercicio_12_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed
qed

section {* Conjunciones *}

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

(* pabalagon *)
lemma ejercicio_13:
assumes "p"
"q"
shows "p ∧ q"
using assms(1, 2) by (rule conjI)

(* benber manperjim josgomrom4 cammonagu raffergon2 marfruman1 alfmarcua
enrparalv chrgencar gleherlop pabbergue antramhur juacanrod hugrubsan
alikan *)
lemma ejercicio_13_1:
assumes "p"
"q"
shows "p ∧ q"
using assms by (rule conjI)

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

(* pabalagon josgomrom4 *)
lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
using assms(1) by (rule conjunct1)

(* benber manperjim cammonagu raffergon2 marfruman1 alfmarcua enrparalv
chrgencar pabbergue gleherlop antramhur hugrubsan juacanrod alikan *)
lemma ejercicio_14_1:
assumes "p ∧ q"
shows "p"
using assms by (rule conjunct1)

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

(* pabalagon manperjim juacanrod josgomrom4 *)
lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
using assms(1) by (rule conjunct2)

(* benber cammonagu raffergon2 marfruman1 alfmarcua enrparalv chrgencar
pabbergue antramhur gleherlop hugrubsan alikan *)
lemma ejercicio_15_1:
assumes "p ∧ q"
shows "q"
using assms by (rule conjunct2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammmonagu enrparalv chrgencar gleherlop pabbergue antramhur
hugrubsan alikan juacanrod cammonagu *)
lemma ejercicio_16:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof -
have 1: "p" using assms(1) by (rule conjunct1)
have 2: "q ∧ r" using assms(1) by (rule conjunct2)
have 3: "q" using 2 by (rule conjunct1)
have 4: "r" using 2 by (rule conjunct2)
have 5: "p ∧ q" using 1 3 by (rule conjI)
show "(p ∧ q) ∧ r" using 5 4 by (rule conjI)
qed

(* benber *)
lemma ejercicio_16_1:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof - (* TODO? *)
have "q ∧ r" using assms by (rule conjunct2)
have "p" using assms by (rule conjunct1)
moreover have "q" using `q ∧ r` by (rule conjunct1)
ultimately have "p ∧ q" by (rule conjI)
moreover have "r" using `q ∧ r` by (rule conjunct2)
ultimately show "(p ∧ q) ∧ r" by (rule conjI)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv hugrubsan
juacanrod alikan *)
lemma ejercicio_17:
assumes 1: "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have 2: "r" using 1 by (rule conjunct2)
have 3: "p ∧ q" using 1 by (rule conjunct1)
have 4: "p" using 3 by (rule conjunct1)
have 5: "q" using 3 by (rule conjunct2)
have 6: "q ∧ r" using 5 2 by (rule conjI)
show ?thesis using 4 6 by (rule conjI)
qed

(* benber *)
lemma ejercicio_17_1:
assumes "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have "p ∧ q" using assms by (rule conjunct1)
have "p" using `p ∧ q` by (rule conjunct1)
moreover have "q ∧ r"
proof (rule conjI)
show "q" using `p ∧ q` by (rule conjunct2)
next
show "r" using assms by (rule conjunct2)
qed
ultimately show ?thesis by (rule conjI)
qed

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

(* pabalagon raffergon2 marfruman1 juacanrod alikan*)
lemma ejercicio_18:
assumes "p ∧ q"
shows "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using assms(1) by (rule conjunct2)
qed

(* benber manperjim josgomrom4 cammonagu alfmarcua chrgencar pabbergue
gleherlop antramhur enrparalv hugrubsan *)
lemma ejercicio_18_1:
assumes "p ∧ q"
shows "p ⟶ q"
proof
show "q" using assms by (rule conjunct2)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_19:
assumes 1: "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof (rule impI)
assume 2: "p"
have 3: "p ⟶ q" using 1 by (rule conjunct1)
have 4: "p ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 3 2 by (rule mp)
have 6: "r" using 4 2 by (rule mp)
show "q ∧ r" using 5 6 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_19_1:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume p
show "q ∧ r"
proof
have "p ⟶ q" using assms by (rule conjunct1)
thus "q" using `p` by (rule mp)
next
have "p ⟶ r" using assms by (rule conjunct2)
thus "r" using `p` by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_20:
assumes 1: "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof (rule conjI)
show "p ⟶ q"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "q" using 3 by (rule conjunct1)
qed
show "p ⟶ r"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "r" using 3 by (rule conjunct2)
qed
qed

(* benber *)
lemma ejercicio_20_1:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
show "p ⟶ q"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "q" by (rule conjunct1)
qed
next
show "p ⟶ r"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "r" by (rule conjunct2)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar pabbergue gleherlop antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_21:
assumes 1: "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p" using 2 by (rule conjunct1)
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 by (rule conjunct2)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_21_1:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ∧ q` have "q" by (rule conjunct2)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_22:
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_22_1:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
with `p` have "p ∧ q" by (rule conjI)
with `p ∧ q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_23:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using 2 by (rule conjunct2)
qed
show "r" using 1 3 by (rule mp)
qed

(* benber cammonagu *)
lemma ejercicio_23_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "q" by (rule conjunct2)
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv hugrubsan juacanrod
cammonagu alikan *)
lemma ejercicio_24:
assumes 1: "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof (rule impI)
assume 2: "p ⟶ q"
have 3: "p" using 1 by (rule conjunct1)
have 4: "q ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 2 3 by (rule mp)
show 6: "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_24_1:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
have "q ⟶ r" using assms by (rule conjunct2)
assume "p ⟶ q"
moreover have "p" using assms by (rule conjunct1)
ultimately have "q" by (rule mp)
with `q ⟶ r` show r by (rule mp)
qed

section {* Disyunciones *}

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

(* pabalagon manperjim josgomrom4 benber cammonagu raffergon2 marfruman1
alfmarcua chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim josgomrom4 benber cammonagu marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
using assms(1) by (rule disjI2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
pabbergue antramhur enrparalv juacanrod hugrubsan cammonagu alikan *)
lemma ejercicio_27:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1 proof (rule disjE)
assume 2: "p" thus "q ∨ p" by (rule disjI2)
next
assume 3: "q" thus "q ∨ p" by (rule disjI1)
qed

(* benber alfmarcua gleherlop *)
lemma ejercicio_27_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms .
moreover have "p ⟹ q ∨ p" by (rule disjI2)
moreover have "q ⟹ q ∨ p" by (rule disjI1)
ultimately show "q ∨ p" by (rule disjE)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
gleherlop alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan
cammonagu alikan *)
lemma ejercicio_28:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q" show "p ∨ r" using 2
proof (rule disjE)
assume 3: p thus "p ∨ r" by (rule disjI1)
next
assume 4: q have r using 1 4 by (rule mp)
thus "p ∨ r" by (rule disjI2)
qed
qed

(* benber *)
lemma ejercicio_28_1:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
moreover have "p ⟹ p ∨ r" by (rule disjI1)
moreover have "q ⟹ p ∨ r"
proof (rule disjI2)
assume "q"
with `q ⟶ r` show "r" by (rule mp)
qed
ultimately show "p ∨ r" by (rule disjE)
qed

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

(* pabalagon juacanrod marfruman1 *)
lemma ejercicio_29:
assumes 1: "p ∨ p"
shows "p"
using 1 proof (rule disjE)
assume "p" thus "p" .
next
assume "p" thus "p" .
qed

(* benber manperjim cammonagu josgomrom4 raffergon2 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv hugrubsan alikan *)
lemma ejercicio_29_1:
assumes "p ∨ p"
shows "p"
using assms by (rule disjE)

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

(* pabalagon manperjim benber josgomrom4 raffergon2 marfruman1
chrgencar alfmarcua pabbergue gleherlop antramhur enrparalv hugrubsan
juacanrod cammonagu alikan *)
lemma ejercicio_30:
assumes "p"
shows "p ∨ p"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_31:
assumes 1: "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r" (is "?R")
using 1 proof (rule disjE)
assume "p" hence "p ∨ q" by (rule disjI1)
thus ?R by (rule disjI1)
next
assume "q ∨ r" thus ?R
proof (rule disjE)
assume "q" hence "p ∨ q" by (rule disjI2)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "r" thus ?thesis by (rule disjI2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_31_1:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
proof -
have "p ∨ (q ∨ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "q ∨ r"
moreover {
assume "q"
hence "p ∨ q" by (rule disjI2)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "r"
hence "(p ∨ q) ∨ r" by (rule disjI2)
}
ultimately have "(p ∨ q) ∨ r" by (rule disjE)
}
ultimately show "(p ∨ q) ∨ r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_32:
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1 proof (rule disjE)
assume "p ∨ q" thus ?thesis
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume q hence "q ∨ r" by (rule disjI1)
thus ?thesis by (rule disjI2)
qed
next
assume r hence "q ∨ r" by (rule disjI2)
thus ?thesis by (rule disjI2)
qed

(* benber cammonagu *)
lemma ejercicio_32_1:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
proof -
have "(p ∨ q) ∨ r" using assms .
moreover {
assume "p ∨ q"
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
hence "q ∨ r" by (rule disjI1)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
moreover {
assume "r"
hence "q ∨ r" by (rule disjI2)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar gleherlop
alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_33:
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: p using 1 by (rule conjunct1)
show ?thesis
proof (rule disjE)
assume 3: q have "p ∧ q" using 2 3 by (rule conjI)
thus ?thesis by (rule disjI1)
next
assume 4: r have "p ∧ r" using 2 4 by (rule conjI)
thus ?thesis by (rule disjI2)
next
show "q ∨ r" using 1 by (rule conjunct2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_33_1:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have "p" using assms by (rule conjunct1)
have "q ∨ r" using assms by (rule conjunct2)
moreover {
assume "q"
with `p` have "p ∧ q" by (rule conjI)
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `p` have "p ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_34:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms(1) proof (rule disjE)
assume 2: "p ∧ q" hence q by (rule conjunct2)
hence 3: "q ∨ r" by (rule disjI1)
have p using 2 by (rule conjunct1)
thus ?thesis using 3 by (rule conjI)
next
assume 4: "p ∧ r" hence r by (rule conjunct2)
hence 5: "q ∨ r" by (rule disjI2)
have p using 4 by (rule conjunct1)
thus ?thesis using 5 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_34_1:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
proof -
have "(p ∧ q) ∨ (p ∧ r)" using assms .
moreover {
assume "p ∧ q"
hence "p" by (rule conjunct1)
moreover {
have "q" using `p ∧ q` by (rule conjunct2)
hence "q ∨ r" by (rule disjI1)
}
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "p ∧ r"
hence "p" by (rule conjunct1)
moreover {
have "r" using `p ∧ r` by (rule conjunct2)
hence "q ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
using assms(1) proof (rule disjE)
assume 1: p hence 2: "p ∨ r" by (rule disjI1)
have "p ∨ q" using 1 by (rule disjI1)
thus ?thesis using 2 by (rule conjI)
next
assume 3: "q ∧ r" hence r by (rule conjunct2)
hence 4: "p ∨ r" by (rule disjI2)
have q using 3 by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
thus ?thesis using 4 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_35_1:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
proof -
have "p ∨ (q ∧ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
moreover have "p ∨ r" using `p` by (rule disjI1)
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "q ∧ r"
{
have "q" using `q ∧ r` by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
}
moreover {
have "r" using `q ∧ r` by (rule conjunct2)
hence "p ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_36:
assumes 1: "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have 2: "p ∨ q" using 1 by (rule conjunct1)
have 3: "p ∨ r" using 1 by (rule conjunct2)
show ?thesis using 2
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 4: q show ?thesis using 3
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 5: r have "q ∧ r" using 4 5 by (rule conjI)
thus ?thesis by (rule disjI2)
qed
qed
qed

(* benber cammonagu *)
lemma ejercicio_36_1:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have "p ∨ q" using assms by (rule conjunct1)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
have "p ∨ r" using assms by (rule conjunct2)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `q` have "q ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_37:
assumes 1: "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof (rule impI)
have 2: "p ⟶ r" using 1 by (rule conjunct1)
have 3: "q ⟶ r" using 1 by (rule conjunct2)
assume 4: "p ∨ q" show "r" using 4
proof (rule disjE)
assume 5: "p" show "r" using 2 5 by (rule mp)
next
assume 6: "q" show "r" using 3 6 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_37_1:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume "p ∨ q"
moreover {
have "p ⟶ r" using assms by (rule conjunct1)
moreover assume "p"
ultimately have "r" by (rule mp)
}
moreover {
have "q ⟶ r" using assms by (rule conjunct2)
moreover assume "q"
ultimately have "r" by (rule mp)
}
ultimately show "r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_38:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof (rule conjI)
show "p ⟶ r"
proof (rule impI)
assume "p" hence 1: "p ∨ q" by (rule disjI1)
show "r" using assms(1) 1 by (rule mp)
qed
next
show "q ⟶ r"
proof (rule impI)
assume q hence 2: "p ∨ q" by (rule disjI2)
show r using assms(1) 2 by (rule mp)
qed
qed

(* benber cammonagu*)
lemma ejercicio_38_1:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
show "p ⟶ r"
proof
assume "p"
hence "p ∨ q" by (rule disjI1)
with assms show "r" by (rule mp)
qed
next
show "q ⟶ r"
proof
assume "q"
hence "p ∨ q" by (rule disjI2)
with assms show "r" by (rule mp)
qed
qed

section {* Negaciones *}

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

(* pabalagon manperjim benber josgomrom4 raffergon2 gleherlop
marfruman1 chrgencar alfmarcua pabbergue enrparalv juacanrod
hugrubsan cammonagu alikan *)
lemma ejercicio_39:
assumes "p"
shows "¬¬p"
using assms(1) by (rule notnotI)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop juacanrod enrparalv hugrubsan alikan *)
lemma ejercicio_40:
assumes 1: "¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: p show q using 1 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_40_1:
assumes "¬p"
shows "p ⟶ q"
proof
assume "p"
with `¬p` show "q" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_41:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 2: "¬q" show "¬p" using 1 2 by (rule mt)
qed

(* benber cammonagu *)
lemma ejercicio_41_1:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with `p ⟶ q` show "¬p" by (rule mt)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_42:
assumes "p∨q"
"¬q"
shows "p"
using assms(1) proof (rule disjE)
assume "p" thus "p" .
next
assume 2: "q" show "p" using assms(2) 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_42_1:
assumes "p∨q"
"¬q"
shows "p"
proof -
note `p ∨ q`
moreover have "p ⟹ p" .
moreover {
assume "q"
with `¬q` have "p" by (rule notE)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_43:
assumes "p ∨ q"
"¬p"
shows "q"
using assms(1) proof (rule disjE)
assume 1: "p" show "q" using assms(2) 1 by (rule notE)
next
assume "q" thus "q" .
qed

(* benber cammonagu*)
lemma ejercicio_43_1:
assumes "p ∨ q"
"¬p"
shows "q"
proof -
note `p ∨ q`
moreover {
assume "p"
with `¬p` have "q" by (rule notE)
}
moreover have "q ⟹ q" .
ultimately show "q" by (rule disjE)
qed

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

(* pabalagon manperjim gleherlop josgomrom4 marfruman1 pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_44:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof (rule notI)
assume 1: "¬p ∧ ¬q" hence 2: "¬p" by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
show "False"
using assms(1) proof (rule disjE)
assume 4: "p" show ?thesis using 2 4 by (rule notE)
next
assume 5: "q" show ?thesis using 3 5 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_44_1:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof
assume "¬p ∧ ¬q"
note `p ∨ q`
moreover {
from `¬p ∧ ¬q` have "¬p" by (rule conjunct1)
moreover assume "p"
ultimately have "False" by (rule notE)
}
moreover {
from `¬p ∧ ¬q` have "¬q" by (rule conjunct2)
moreover assume "q"
ultimately have "False" by (rule notE)
}
ultimately show "False" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_45:
assumes 1: "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof (rule notI)
assume 2: "¬p ∨ ¬q" have 3: "p" using 1 by (rule conjunct1)
have 4: "q" using 1 by (rule conjunct2)
show "False" using 2
proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_45_1:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
moreover {
assume "¬p"
moreover have "p" using `p ∧ q` by (rule conjunct1)
ultimately have "False" by (rule notE)
}
moreover {
assume "¬q"
moreover have "q" using `p ∧ q` by (rule conjunct2)
ultimately have "False" by (rule notE)
}
ultimately show False by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_46:
assumes 1: "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
show "¬p"
proof (rule notI)
assume p hence 2: "p ∨ q" by (rule disjI1)
show False using 1 2 by (rule notE)
qed
show "¬q"
proof (rule notI)
assume q hence 3: "p ∨ q" by (rule disjI2)
show False using 1 3 by (rule notE)
qed
qed

(* benber cammmonagu *)
lemma ejercicio_46_1:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof (rule ccontr)
assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1)
with assms show "False" by (rule notE)
qed
next
show "¬q"
proof (rule ccontr)
assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2)
with assms show "False" by (rule notE)
qed
qed

(* alfmarcua *)
lemma ejercicio_46_2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
have "p ⟹ p ∨ q" by (rule disjI1)
then have "p ⟶ p ∨ q" by (rule impI)
then show "¬ p" using assms by (rule mt)
next
have "q ⟹ p ∨ q" by (rule disjI2)
then have "q ⟶ p ∨ q" by (rule impI)
then show "¬ q" using assms by (rule mt)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbregue juacanrod
hugrubsan alikan *)
lemma ejercicio_47:
assumes 1: "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have 2: "¬p" using 1 by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
assume 4: "p ∨ q"
show False
using 4 proof (rule disjE)
assume 5: p show ?thesis using 2 5 by (rule notE)
next
assume 6: q show ?thesis using 3 6 by (rule notE)
qed
qed

(* benber gleherlop cammonagu*)
lemma ejercicio_47_1:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
hence "¬(¬p ∧ ¬q)" by (rule ejercicio_44_1)
thus "False" using assms by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_47_2:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have "¬ p" using assms by (rule conjunct1)
have "¬ q" using assms by (rule conjunct2)
assume "p ∨ q"
then have "q" using `¬ p` by (rule ejercicio_43)
show False using `¬ q` `q` by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbergue juacanrod
hugrubsan alikan *)
lemma ejercicio_48:
assumes 1: "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof (rule notI)
assume 2: "p ∧ q" hence 3: p by (rule conjunct1)
have 4: q using 2 by (rule conjunct2)
show False
using 1 proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua gleherlop cammonagu *)
lemma ejercicio_48_1:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "¬(¬p ∨ ¬q)" by (rule ejercicio_45_1)
thus "False" using assms by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcu gleherlop
hugrubsan juacanrod cammonagu alikan *)
lemma ejercicio_49:
"¬(p ∧ ¬p)"
proof (rule notI)
assume 1: "p ∧ ¬p" hence 2: p by (rule conjunct1)
have "¬p" using 1 by (rule conjunct2)
thus "False" using 2 by (rule notE)
qed

(* benber *)
lemma ejercicio_49_1:
"¬(p ∧ ¬p)"
proof
assume "p ∧ ¬p"
hence "¬p" by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "False" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan alikan *)
lemma ejercicio_50:
assumes 1: "p ∧ ¬p"
shows "q"
proof (rule notE)
show p using 1 by (rule conjunct1)
show "¬p" using 1 by (rule conjunct2)
qed

(* benber cammonagu*)
lemma ejercicio_50_1:
assumes "p ∧ ¬p"
shows "q"
proof -
have "¬p" using `p ∧ ¬p` by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "q" by (rule notE)
qed

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

(* pabalagon manperjim benber raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan cammmonagu alikan *)
lemma ejercicio_51:
assumes "¬¬p"
shows "p"
using assms(1) by (rule notnotD)

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

(* pabalagon manperjim marfruman1 josgomrom4 juacanrod pabbergue alikan *)
lemma ejercicio_52:
"p ∨ ¬p"
proof (rule ccontr)
assume 1: "¬(p ∨ ¬p)"
have 2: "¬p" proof (rule notI)
assume p hence 3: "p ∨ ¬p" by (rule disjI1)
show "False" using 1 3 by (rule notE)
qed
have 4: "p ∨ ¬p" using 2 by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_52_1:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
hence "¬p ∧ ¬¬p" by (rule ejercicio_46_1)
hence "¬p" by (rule conjunct1)
moreover {
have "¬¬p" using `¬p ∧ ¬¬p` by (rule conjunct2)
hence "p" by (rule notnotD)
}
ultimately show "False" by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_52_2:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
then have "¬ p ∧ ¬¬ p" by (rule ejercicio_46)
then show False by (rule ejercicio_50)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
juacanrod pabbergue *)
lemma ejercicio_53:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume 1: "(p ⟶ q) ⟶ p"
show p proof (rule ccontr)
assume 2: "¬p"
have 3: "¬(p ⟶ q)" using 1 2 by (rule mt)
have 4: "p ⟶ q" proof (rule impI)
assume 5: p show q using 2 5 by (rule notE)
qed
show False using 3 4 by (rule notE)
qed
qed

(* benber cammonagu *)
lemma ejercicio_53_1:
"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume "(p ⟶ q) ⟶ p"
have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover have "p ⟹ p" .
moreover {
assume "¬ p"
hence "p ⟶ q" by (rule ejercicio_40_1)
with `(p ⟶ q) ⟶ p` have "p" by (rule mp)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_54:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p" hence 3: "¬¬p" by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt)
thus "q" by (rule notnotD)
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_54_1:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

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

(* pabalagon marfruman1*)
lemma ejercicio_55:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume 2: "¬(p ∨ q)"
have 3: "p"
proof (rule ccontr)
assume 4: "¬p"
have 5: "q"
proof (rule ccontr)
assume 6: "¬q" have 7: "¬p ∧ ¬q" using 4 6 by (rule conjI)
show False using 1 7 by (rule notE)
qed
have 8: "p ∨ q" using 5 by (rule disjI2)
show False using 2 8 by (rule notE)
qed
have 9: "p ∨ q" using 3 by (rule disjI1)
show False using 2 9 by (rule notE)
qed

(* benber alfmarcua josgomrom4 manperjim pabbergue juacanrod cammonagu *)
lemma ejercicio_55_1:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume "¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule ejercicio_46_1)
with assms show False by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_56:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
show 3: p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 1 4 by (rule notE)
qed
show 5: q
proof (rule ccontr)
assume "¬q" hence 6: "¬p ∨ ¬q" by (rule disjI2)
show False using 1 6 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_56_1:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule ejercicio_46_1)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
moreover {
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
}
ultimately show "p ∧ q" by (rule conjI)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_57:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume 2: "¬(¬p ∨ ¬q)"
show False using 1
proof (rule notE)
show 3: "p ∧ q"
proof (rule conjI)
show p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 2 4 by (rule notE)
qed
next
show q
proof (rule ccontr)
assume "¬q" hence 5: "¬p ∨ ¬q" by (rule disjI2)
show False using 2 5 by (rule notE)
qed
qed
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_57_1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_56_1)
with assms show "False" by (rule notE)
qed

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

(* pabalagon manperjim josgomrom4 marfruman1 juacanrod pabbergue *)
lemma ejercicio_58:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "(p ⟶ q) ∨ ¬(p ⟶ q)" proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ ¬(p ⟶ q))"
have 2: "¬(p ⟶ q)" proof (rule notI)
assume "p ⟶ q"
hence 3: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
hence 4: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed
thus ?thesis proof (rule disjE)
assume "p ⟶ q" thus ?thesis by (rule disjI1)
next
assume 1: "¬(p ⟶ q)"
have "q ⟶ p" proof (rule impI)
assume 2: q
have 3: "p ⟶ q" proof (rule impI)
assume p show q using 2 .
qed
show p using 1 3 by (rule notE)
qed
thus ?thesis by (rule disjI2)
qed
qed

(* pabalagon gleherlop *)
lemma ejercicio_58_2:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "(p ∧ ¬q) ∧ (q ∧ ¬p)" by simp
hence "p ∧ ¬q" ..
hence 2: p ..
have "q ∧ ¬p" using 1 ..
hence 3: "¬p" ..
show False using 3 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_58_1:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume "¬ ((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "¬(p ⟶ q) ∧ ¬(q ⟶ p)" by (rule ejercicio_46_1)

have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
moreover {
assume "¬p"
hence "p ⟶ q" by (rule ejercicio_40_1)

have "¬(p ⟶ q)" using 1 by (rule conjunct1)
hence "False" using `p ⟶ q` by (rule notE)
}
ultimately show "False" by (rule disjE)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
qed

(* alfmarcua *)
lemma ejercicio_58_3:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
show "p ∨ ¬ p" by (rule ejercicio_52)
next
assume "¬p"
then have "p ⟶ q" by (rule ejercicio_40)
then show ?thesis by (rule disjI1)
next
assume "p"
then have "q ⟶ p" by (rule ejercicio_7)
then show ?thesis by (rule disjI2)
qed

end
</source>

Relación 7

2019-02-28T13:12:45Z

Jalonso:

<source lang="isabelle">
chapter {* R6: Deducción natural proposicional *}

theory R6_Deduccion_natural_proposicional_alu
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es demostrar cada uno de los ejercicios
usando sólo las reglas básicas de deducción natural de la lógica
proposicional (sin usar el método auto).

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

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

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

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

section {* Implicaciones *}

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

(* pabalagon manperjim josgomrom4 cammonagu raffergon2 chrgencar
gleherlop giafus1 marfruman1 enrparalv pabbergue antramhur alikan
juacanrod hugrubsan *)
lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
proof -
show "q" using 1 2 by (rule mp)
qed

(* benber alfmarcua *)
lemma ejercicio_1_1:
assumes "p ⟶ q"
"p"
shows "q"
using assms by (rule mp)

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_2:
assumes 1: "p ⟶ q" and
2: "q ⟶ r" and
3: "p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed

(* benber *)
lemma ejercicio_2_1:
assumes "p ⟶ q"
"q ⟶ r"
"p"
shows "r"
proof -
have "q" using `p ⟶ q` `p` by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_3:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p ⟶ q" and
3: "p"
shows "r"
proof -
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_3_1:
assumes "p ⟶ (q ⟶ r)"
"p ⟶ q"
"p"
shows "r"
proof -
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu chrgencar raffergon2
gleherlop giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_4:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof -
{ assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "r" using 2 4 by (rule mp)}
thus "p ⟶ r" by (rule impI)
qed

(* benber *)
lemma ejercicio_4_1:
assumes "p ⟶ q"
"q ⟶ r"
shows "p ⟶ r"
proof
assume p
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim raffergon2 giafus1 gleherlop marfruman1 alfmarcua
enrparalv chrgencar pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_5:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
show "r" using 4 2 by (rule mp)
qed
qed

(* benber josgomrom4 juacanrod cammonagu *)
lemma ejercicio_5_1:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof
assume "q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
thus "r" using `q` by (rule mp)
qed
qed

(* pabalagon *)
lemma ejercicio_5_2:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{ assume 2: "q"
{ assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "r" using 4 2 by (rule mp)}
hence "p ⟶ r" by (rule impI)
}
thus "q ⟶ (p ⟶ r)" by (rule impI)
qed

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

(* pabalagon manperjim cammonagu chrgencar raffergon2 gleherlop giafus1
marfruman1 alfmarcua enrparalv pabbergue antramhur alikan juacanrod
hugrubsan *)
lemma ejercicio_6:
assumes 1: "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed

(* benber josgomrom4 *)
lemma ejercicio_6_1:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ⟶ q` `p` have "q" by (rule mp)
ultimately show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 gleherlop
marfruman1 enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_7:
assumes 1: "p"
shows "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed

(* benber cammonagu juacanrod chrgencar *)
lemma ejercicio_7_1:
assumes "p"
shows "q ⟶ p"
proof
show "p" using `p` .
qed

(* alfmarcua *)
lemma ejercicio_7_2:
assumes "p"
shows "q ⟶ p"
using assms by (rule impI)

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 marfruman1
enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_8:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed
qed

(* benber cammonagu gleherlop chrgencar juacanrod alfmarcua *)
lemma ejercicio_8_1:
"p ⟶ (q ⟶ p)"
using ejercicio_7_1 by (rule impI)

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

(* pabalagon manperjim raffergon2 giafus1 marfruman1 alfmarcua enrparalv
gleherlop antramhur alikan hugrubsan *)
lemma ejercicio_9:
assumes 1: "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q ⟶ r"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu chrgencar juacanrod pabbergue *)
lemma ejercicio_9_1:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof
assume "q ⟶ r"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop alfmarcua
enrparalv pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_10:
assumes 1: "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof (rule impI)
assume 2: "r"
show "q ⟶ (p ⟶ s)"
proof (rule impI)
assume 3: "q"
show "p ⟶ s"
proof (rule impI)
assume 4: "p"
have 5: "q ⟶ (r ⟶ s)" using 1 4 by (rule mp)
have 6: "r ⟶ s" using 5 3 by (rule mp)
show "s" using 6 2 by (rule mp)
qed
qed
qed

(* benber josgomrom4 cammonagu chrgencar giafus1 *)
lemma ejercicio_10_1:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof
assume "r"
show "q ⟶ (p ⟶ s)"
proof
assume "q"
show "p ⟶ s"
proof
assume "p"
with `p ⟶ (q ⟶ (r ⟶ s))`
have "q ⟶ (r ⟶ s)" by (rule mp)
hence "r ⟶ s" using `q` by (rule mp)
thus "s" using `r` by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim josgomrom4 gleherlop cammonagu giafus1 alfmarcua
chrgencar pabbergue alikan juacanrod hugrubsan *)
lemma ejercicio_11:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)" using 1 ejercicio_6 by simp
qed

(* pabalagon raffergon2 marfruman1 enrparalv antramhur *)
lemma ejercicio_11_2:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed
qed

(* benber *)
lemma ejercicio_11_1:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume p
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show r by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop enrparalv
pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_12:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ⟶ q"
proof (rule impI)
assume 5: "p"
show "q" using 3 by this
qed
show "r" using 1 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu giafus1 alfmarcua chrgencar *)
lemma ejercicio_12_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed
qed

section {* Conjunciones *}

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

(* pabalagon *)
lemma ejercicio_13:
assumes "p"
"q"
shows "p ∧ q"
using assms(1, 2) by (rule conjI)

(* benber manperjim josgomrom4 cammonagu raffergon2 marfruman1 alfmarcua
enrparalv chrgencar gleherlop pabbergue antramhur juacanrod hugrubsan
alikan *)
lemma ejercicio_13_1:
assumes "p"
"q"
shows "p ∧ q"
using assms by (rule conjI)

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

(* pabalagon josgomrom4 *)
lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
using assms(1) by (rule conjunct1)

(* benber manperjim cammonagu raffergon2 marfruman1 alfmarcua enrparalv
chrgencar pabbergue gleherlop antramhur hugrubsan juacanrod alikan *)
lemma ejercicio_14_1:
assumes "p ∧ q"
shows "p"
using assms by (rule conjunct1)

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

(* pabalagon manperjim juacanrod josgomrom4 *)
lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
using assms(1) by (rule conjunct2)

(* benber cammonagu raffergon2 marfruman1 alfmarcua enrparalv chrgencar
pabbergue antramhur gleherlop hugrubsan alikan *)
lemma ejercicio_15_1:
assumes "p ∧ q"
shows "q"
using assms by (rule conjunct2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammmonagu enrparalv chrgencar gleherlop pabbergue antramhur
hugrubsan alikan juacanrod cammonagu *)
lemma ejercicio_16:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof -
have 1: "p" using assms(1) by (rule conjunct1)
have 2: "q ∧ r" using assms(1) by (rule conjunct2)
have 3: "q" using 2 by (rule conjunct1)
have 4: "r" using 2 by (rule conjunct2)
have 5: "p ∧ q" using 1 3 by (rule conjI)
show "(p ∧ q) ∧ r" using 5 4 by (rule conjI)
qed

(* benber *)
lemma ejercicio_16_1:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof - (* TODO? *)
have "q ∧ r" using assms by (rule conjunct2)
have "p" using assms by (rule conjunct1)
moreover have "q" using `q ∧ r` by (rule conjunct1)
ultimately have "p ∧ q" by (rule conjI)
moreover have "r" using `q ∧ r` by (rule conjunct2)
ultimately show "(p ∧ q) ∧ r" by (rule conjI)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv hugrubsan
juacanrod alikan *)
lemma ejercicio_17:
assumes 1: "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have 2: "r" using 1 by (rule conjunct2)
have 3: "p ∧ q" using 1 by (rule conjunct1)
have 4: "p" using 3 by (rule conjunct1)
have 5: "q" using 3 by (rule conjunct2)
have 6: "q ∧ r" using 5 2 by (rule conjI)
show ?thesis using 4 6 by (rule conjI)
qed

(* benber *)
lemma ejercicio_17_1:
assumes "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have "p ∧ q" using assms by (rule conjunct1)
have "p" using `p ∧ q` by (rule conjunct1)
moreover have "q ∧ r"
proof (rule conjI)
show "q" using `p ∧ q` by (rule conjunct2)
next
show "r" using assms by (rule conjunct2)
qed
ultimately show ?thesis by (rule conjI)
qed

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

(* pabalagon raffergon2 marfruman1 juacanrod alikan*)
lemma ejercicio_18:
assumes "p ∧ q"
shows "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using assms(1) by (rule conjunct2)
qed

(* benber manperjim josgomrom4 cammonagu alfmarcua chrgencar pabbergue
gleherlop antramhur enrparalv hugrubsan *)
lemma ejercicio_18_1:
assumes "p ∧ q"
shows "p ⟶ q"
proof
show "q" using assms by (rule conjunct2)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_19:
assumes 1: "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof (rule impI)
assume 2: "p"
have 3: "p ⟶ q" using 1 by (rule conjunct1)
have 4: "p ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 3 2 by (rule mp)
have 6: "r" using 4 2 by (rule mp)
show "q ∧ r" using 5 6 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_19_1:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume p
show "q ∧ r"
proof
have "p ⟶ q" using assms by (rule conjunct1)
thus "q" using `p` by (rule mp)
next
have "p ⟶ r" using assms by (rule conjunct2)
thus "r" using `p` by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_20:
assumes 1: "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof (rule conjI)
show "p ⟶ q"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "q" using 3 by (rule conjunct1)
qed
show "p ⟶ r"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "r" using 3 by (rule conjunct2)
qed
qed

(* benber *)
lemma ejercicio_20_1:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
show "p ⟶ q"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "q" by (rule conjunct1)
qed
next
show "p ⟶ r"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "r" by (rule conjunct2)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar pabbergue gleherlop antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_21:
assumes 1: "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p" using 2 by (rule conjunct1)
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 by (rule conjunct2)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_21_1:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ∧ q` have "q" by (rule conjunct2)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_22:
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_22_1:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
with `p` have "p ∧ q" by (rule conjI)
with `p ∧ q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_23:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using 2 by (rule conjunct2)
qed
show "r" using 1 3 by (rule mp)
qed

(* benber cammonagu *)
lemma ejercicio_23_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "q" by (rule conjunct2)
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv hugrubsan juacanrod
cammonagu alikan *)
lemma ejercicio_24:
assumes 1: "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof (rule impI)
assume 2: "p ⟶ q"
have 3: "p" using 1 by (rule conjunct1)
have 4: "q ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 2 3 by (rule mp)
show 6: "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_24_1:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
have "q ⟶ r" using assms by (rule conjunct2)
assume "p ⟶ q"
moreover have "p" using assms by (rule conjunct1)
ultimately have "q" by (rule mp)
with `q ⟶ r` show r by (rule mp)
qed

section {* Disyunciones *}

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

(* pabalagon manperjim josgomrom4 benber cammonagu raffergon2 marfruman1
alfmarcua chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim josgomrom4 benber cammonagu marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
using assms(1) by (rule disjI2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
pabbergue antramhur enrparalv juacanrod hugrubsan cammonagu alikan *)
lemma ejercicio_27:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1 proof (rule disjE)
assume 2: "p" thus "q ∨ p" by (rule disjI2)
next
assume 3: "q" thus "q ∨ p" by (rule disjI1)
qed

(* benber alfmarcua gleherlop *)
lemma ejercicio_27_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms .
moreover have "p ⟹ q ∨ p" by (rule disjI2)
moreover have "q ⟹ q ∨ p" by (rule disjI1)
ultimately show "q ∨ p" by (rule disjE)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
gleherlop alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan
cammonagu alikan *)
lemma ejercicio_28:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q" show "p ∨ r" using 2
proof (rule disjE)
assume 3: p thus "p ∨ r" by (rule disjI1)
next
assume 4: q have r using 1 4 by (rule mp)
thus "p ∨ r" by (rule disjI2)
qed
qed

(* benber *)
lemma ejercicio_28_1:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
moreover have "p ⟹ p ∨ r" by (rule disjI1)
moreover have "q ⟹ p ∨ r"
proof (rule disjI2)
assume "q"
with `q ⟶ r` show "r" by (rule mp)
qed
ultimately show "p ∨ r" by (rule disjE)
qed

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

(* pabalagon juacanrod marfruman1 *)
lemma ejercicio_29:
assumes 1: "p ∨ p"
shows "p"
using 1 proof (rule disjE)
assume "p" thus "p" .
next
assume "p" thus "p" .
qed

(* benber manperjim cammonagu josgomrom4 raffergon2 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv hugrubsan alikan *)
lemma ejercicio_29_1:
assumes "p ∨ p"
shows "p"
using assms by (rule disjE)

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

(* pabalagon manperjim benber josgomrom4 raffergon2 marfruman1
chrgencar alfmarcua pabbergue gleherlop antramhur enrparalv hugrubsan
juacanrod cammonagu alikan *)
lemma ejercicio_30:
assumes "p"
shows "p ∨ p"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_31:
assumes 1: "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r" (is "?R")
using 1 proof (rule disjE)
assume "p" hence "p ∨ q" by (rule disjI1)
thus ?R by (rule disjI1)
next
assume "q ∨ r" thus ?R
proof (rule disjE)
assume "q" hence "p ∨ q" by (rule disjI2)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "r" thus ?thesis by (rule disjI2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_31_1:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
proof -
have "p ∨ (q ∨ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "q ∨ r"
moreover {
assume "q"
hence "p ∨ q" by (rule disjI2)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "r"
hence "(p ∨ q) ∨ r" by (rule disjI2)
}
ultimately have "(p ∨ q) ∨ r" by (rule disjE)
}
ultimately show "(p ∨ q) ∨ r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_32:
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1 proof (rule disjE)
assume "p ∨ q" thus ?thesis
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume q hence "q ∨ r" by (rule disjI1)
thus ?thesis by (rule disjI2)
qed
next
assume r hence "q ∨ r" by (rule disjI2)
thus ?thesis by (rule disjI2)
qed

(* benber cammonagu *)
lemma ejercicio_32_1:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
proof -
have "(p ∨ q) ∨ r" using assms .
moreover {
assume "p ∨ q"
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
hence "q ∨ r" by (rule disjI1)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
moreover {
assume "r"
hence "q ∨ r" by (rule disjI2)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar gleherlop
alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_33:
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: p using 1 by (rule conjunct1)
show ?thesis
proof (rule disjE)
assume 3: q have "p ∧ q" using 2 3 by (rule conjI)
thus ?thesis by (rule disjI1)
next
assume 4: r have "p ∧ r" using 2 4 by (rule conjI)
thus ?thesis by (rule disjI2)
next
show "q ∨ r" using 1 by (rule conjunct2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_33_1:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have "p" using assms by (rule conjunct1)
have "q ∨ r" using assms by (rule conjunct2)
moreover {
assume "q"
with `p` have "p ∧ q" by (rule conjI)
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `p` have "p ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_34:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms(1) proof (rule disjE)
assume 2: "p ∧ q" hence q by (rule conjunct2)
hence 3: "q ∨ r" by (rule disjI1)
have p using 2 by (rule conjunct1)
thus ?thesis using 3 by (rule conjI)
next
assume 4: "p ∧ r" hence r by (rule conjunct2)
hence 5: "q ∨ r" by (rule disjI2)
have p using 4 by (rule conjunct1)
thus ?thesis using 5 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_34_1:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
proof -
have "(p ∧ q) ∨ (p ∧ r)" using assms .
moreover {
assume "p ∧ q"
hence "p" by (rule conjunct1)
moreover {
have "q" using `p ∧ q` by (rule conjunct2)
hence "q ∨ r" by (rule disjI1)
}
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "p ∧ r"
hence "p" by (rule conjunct1)
moreover {
have "r" using `p ∧ r` by (rule conjunct2)
hence "q ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
using assms(1) proof (rule disjE)
assume 1: p hence 2: "p ∨ r" by (rule disjI1)
have "p ∨ q" using 1 by (rule disjI1)
thus ?thesis using 2 by (rule conjI)
next
assume 3: "q ∧ r" hence r by (rule conjunct2)
hence 4: "p ∨ r" by (rule disjI2)
have q using 3 by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
thus ?thesis using 4 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_35_1:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
proof -
have "p ∨ (q ∧ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
moreover have "p ∨ r" using `p` by (rule disjI1)
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "q ∧ r"
{
have "q" using `q ∧ r` by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
}
moreover {
have "r" using `q ∧ r` by (rule conjunct2)
hence "p ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_36:
assumes 1: "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have 2: "p ∨ q" using 1 by (rule conjunct1)
have 3: "p ∨ r" using 1 by (rule conjunct2)
show ?thesis using 2
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 4: q show ?thesis using 3
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 5: r have "q ∧ r" using 4 5 by (rule conjI)
thus ?thesis by (rule disjI2)
qed
qed
qed

(* benber cammonagu *)
lemma ejercicio_36_1:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have "p ∨ q" using assms by (rule conjunct1)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
have "p ∨ r" using assms by (rule conjunct2)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `q` have "q ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_37:
assumes 1: "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof (rule impI)
have 2: "p ⟶ r" using 1 by (rule conjunct1)
have 3: "q ⟶ r" using 1 by (rule conjunct2)
assume 4: "p ∨ q" show "r" using 4
proof (rule disjE)
assume 5: "p" show "r" using 2 5 by (rule mp)
next
assume 6: "q" show "r" using 3 6 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_37_1:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume "p ∨ q"
moreover {
have "p ⟶ r" using assms by (rule conjunct1)
moreover assume "p"
ultimately have "r" by (rule mp)
}
moreover {
have "q ⟶ r" using assms by (rule conjunct2)
moreover assume "q"
ultimately have "r" by (rule mp)
}
ultimately show "r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_38:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof (rule conjI)
show "p ⟶ r"
proof (rule impI)
assume "p" hence 1: "p ∨ q" by (rule disjI1)
show "r" using assms(1) 1 by (rule mp)
qed
next
show "q ⟶ r"
proof (rule impI)
assume q hence 2: "p ∨ q" by (rule disjI2)
show r using assms(1) 2 by (rule mp)
qed
qed

(* benber cammonagu*)
lemma ejercicio_38_1:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
show "p ⟶ r"
proof
assume "p"
hence "p ∨ q" by (rule disjI1)
with assms show "r" by (rule mp)
qed
next
show "q ⟶ r"
proof
assume "q"
hence "p ∨ q" by (rule disjI2)
with assms show "r" by (rule mp)
qed
qed

section {* Negaciones *}

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

(* pabalagon manperjim benber josgomrom4 raffergon2 gleherlop
marfruman1 chrgencar alfmarcua pabbergue enrparalv juacanrod
hugrubsan cammonagu alikan *)
lemma ejercicio_39:
assumes "p"
shows "¬¬p"
using assms(1) by (rule notnotI)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop juacanrod enrparalv hugrubsan alikan *)
lemma ejercicio_40:
assumes 1: "¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: p show q using 1 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_40_1:
assumes "¬p"
shows "p ⟶ q"
proof
assume "p"
with `¬p` show "q" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_41:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 2: "¬q" show "¬p" using 1 2 by (rule mt)
qed

(* benber cammonagu *)
lemma ejercicio_41_1:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with `p ⟶ q` show "¬p" by (rule mt)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_42:
assumes "p∨q"
"¬q"
shows "p"
using assms(1) proof (rule disjE)
assume "p" thus "p" .
next
assume 2: "q" show "p" using assms(2) 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_42_1:
assumes "p∨q"
"¬q"
shows "p"
proof -
note `p ∨ q`
moreover have "p ⟹ p" .
moreover {
assume "q"
with `¬q` have "p" by (rule notE)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_43:
assumes "p ∨ q"
"¬p"
shows "q"
using assms(1) proof (rule disjE)
assume 1: "p" show "q" using assms(2) 1 by (rule notE)
next
assume "q" thus "q" .
qed

(* benber cammonagu*)
lemma ejercicio_43_1:
assumes "p ∨ q"
"¬p"
shows "q"
proof -
note `p ∨ q`
moreover {
assume "p"
with `¬p` have "q" by (rule notE)
}
moreover have "q ⟹ q" .
ultimately show "q" by (rule disjE)
qed

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

(* pabalagon manperjim gleherlop josgomrom4 marfruman1 pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_44:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof (rule notI)
assume 1: "¬p ∧ ¬q" hence 2: "¬p" by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
show "False"
using assms(1) proof (rule disjE)
assume 4: "p" show ?thesis using 2 4 by (rule notE)
next
assume 5: "q" show ?thesis using 3 5 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_44_1:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof
assume "¬p ∧ ¬q"
note `p ∨ q`
moreover {
from `¬p ∧ ¬q` have "¬p" by (rule conjunct1)
moreover assume "p"
ultimately have "False" by (rule notE)
}
moreover {
from `¬p ∧ ¬q` have "¬q" by (rule conjunct2)
moreover assume "q"
ultimately have "False" by (rule notE)
}
ultimately show "False" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_45:
assumes 1: "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof (rule notI)
assume 2: "¬p ∨ ¬q" have 3: "p" using 1 by (rule conjunct1)
have 4: "q" using 1 by (rule conjunct2)
show "False" using 2
proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_45_1:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
moreover {
assume "¬p"
moreover have "p" using `p ∧ q` by (rule conjunct1)
ultimately have "False" by (rule notE)
}
moreover {
assume "¬q"
moreover have "q" using `p ∧ q` by (rule conjunct2)
ultimately have "False" by (rule notE)
}
ultimately show False by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_46:
assumes 1: "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
show "¬p"
proof (rule notI)
assume p hence 2: "p ∨ q" by (rule disjI1)
show False using 1 2 by (rule notE)
qed
show "¬q"
proof (rule notI)
assume q hence 3: "p ∨ q" by (rule disjI2)
show False using 1 3 by (rule notE)
qed
qed

(* benber cammmonagu *)
lemma ejercicio_46_1:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof (rule ccontr)
assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1)
with assms show "False" by (rule notE)
qed
next
show "¬q"
proof (rule ccontr)
assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2)
with assms show "False" by (rule notE)
qed
qed

(* alfmarcua *)
lemma ejercicio_46_2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
have "p ⟹ p ∨ q" by (rule disjI1)
then have "p ⟶ p ∨ q" by (rule impI)
then show "¬ p" using assms by (rule mt)
next
have "q ⟹ p ∨ q" by (rule disjI2)
then have "q ⟶ p ∨ q" by (rule impI)
then show "¬ q" using assms by (rule mt)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbregue juacanrod
hugrubsan alikan *)
lemma ejercicio_47:
assumes 1: "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have 2: "¬p" using 1 by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
assume 4: "p ∨ q"
show False
using 4 proof (rule disjE)
assume 5: p show ?thesis using 2 5 by (rule notE)
next
assume 6: q show ?thesis using 3 6 by (rule notE)
qed
qed

(* benber gleherlop cammonagu*)
lemma ejercicio_47_1:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
hence "¬(¬p ∧ ¬q)" by (rule ejercicio_44_1)
thus "False" using assms by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_47_2:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have "¬ p" using assms by (rule conjunct1)
have "¬ q" using assms by (rule conjunct2)
assume "p ∨ q"
then have "q" using `¬ p` by (rule ejercicio_43)
show False using `¬ q` `q` by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbergue juacanrod
hugrubsan alikan *)
lemma ejercicio_48:
assumes 1: "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof (rule notI)
assume 2: "p ∧ q" hence 3: p by (rule conjunct1)
have 4: q using 2 by (rule conjunct2)
show False
using 1 proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua gleherlop cammonagu *)
lemma ejercicio_48_1:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "¬(¬p ∨ ¬q)" by (rule ejercicio_45_1)
thus "False" using assms by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcu gleherlop
hugrubsan juacanrod cammonagu alikan *)
lemma ejercicio_49:
"¬(p ∧ ¬p)"
proof (rule notI)
assume 1: "p ∧ ¬p" hence 2: p by (rule conjunct1)
have "¬p" using 1 by (rule conjunct2)
thus "False" using 2 by (rule notE)
qed

(* benber *)
lemma ejercicio_49_1:
"¬(p ∧ ¬p)"
proof
assume "p ∧ ¬p"
hence "¬p" by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "False" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan alikan *)
lemma ejercicio_50:
assumes 1: "p ∧ ¬p"
shows "q"
proof (rule notE)
show p using 1 by (rule conjunct1)
show "¬p" using 1 by (rule conjunct2)
qed

(* benber cammonagu*)
lemma ejercicio_50_1:
assumes "p ∧ ¬p"
shows "q"
proof -
have "¬p" using `p ∧ ¬p` by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "q" by (rule notE)
qed

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

(* pabalagon manperjim benber raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan cammmonagu alikan *)
lemma ejercicio_51:
assumes "¬¬p"
shows "p"
using assms(1) by (rule notnotD)

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

(* pabalagon manperjim marfruman1 josgomrom4 juacanrod pabbergue alikan *)
lemma ejercicio_52:
"p ∨ ¬p"
proof (rule ccontr)
assume 1: "¬(p ∨ ¬p)"
have 2: "¬p" proof (rule notI)
assume p hence 3: "p ∨ ¬p" by (rule disjI1)
show "False" using 1 3 by (rule notE)
qed
have 4: "p ∨ ¬p" using 2 by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_52_1:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
hence "¬p ∧ ¬¬p" by (rule ejercicio_46_1)
hence "¬p" by (rule conjunct1)
moreover {
have "¬¬p" using `¬p ∧ ¬¬p` by (rule conjunct2)
hence "p" by (rule notnotD)
}
ultimately show "False" by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_52_2:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
then have "¬ p ∧ ¬¬ p" by (rule ejercicio_46)
then show False by (rule ejercicio_50)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
juacanrod pabbergue *)
lemma ejercicio_53:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume 1: "(p ⟶ q) ⟶ p"
show p proof (rule ccontr)
assume 2: "¬p"
have 3: "¬(p ⟶ q)" using 1 2 by (rule mt)
have 4: "p ⟶ q" proof (rule impI)
assume 5: p show q using 2 5 by (rule notE)
qed
show False using 3 4 by (rule notE)
qed
qed

(* benber cammonagu *)
lemma ejercicio_53_1:
"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume "(p ⟶ q) ⟶ p"
have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover have "p ⟹ p" .
moreover {
assume "¬ p"
hence "p ⟶ q" by (rule ejercicio_40_1)
with `(p ⟶ q) ⟶ p` have "p" by (rule mp)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_54:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p" hence 3: "¬¬p" by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt)
thus "q" by (rule notnotD)
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_54_1:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

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

(* pabalagon marfruman1*)
lemma ejercicio_55:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume 2: "¬(p ∨ q)"
have 3: "p"
proof (rule ccontr)
assume 4: "¬p"
have 5: "q"
proof (rule ccontr)
assume 6: "¬q" have 7: "¬p ∧ ¬q" using 4 6 by (rule conjI)
show False using 1 7 by (rule notE)
qed
have 8: "p ∨ q" using 5 by (rule disjI2)
show False using 2 8 by (rule notE)
qed
have 9: "p ∨ q" using 3 by (rule disjI1)
show False using 2 9 by (rule notE)
qed

(* benber alfmarcua josgomrom4 manperjim pabbergue juacanrod cammonagu *)
lemma ejercicio_55_1:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume "¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule ejercicio_46_1)
with assms show False by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_56:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
show 3: p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 1 4 by (rule notE)
qed
show 5: q
proof (rule ccontr)
assume "¬q" hence 6: "¬p ∨ ¬q" by (rule disjI2)
show False using 1 6 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_56_1:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule ejercicio_46_1)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
moreover {
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
}
ultimately show "p ∧ q" by (rule conjI)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_57:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume 2: "¬(¬p ∨ ¬q)"
show False using 1
proof (rule notE)
show 3: "p ∧ q"
proof (rule conjI)
show p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 2 4 by (rule notE)
qed
next
show q
proof (rule ccontr)
assume "¬q" hence 5: "¬p ∨ ¬q" by (rule disjI2)
show False using 2 5 by (rule notE)
qed
qed
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_57_1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_56_1)
with assms show "False" by (rule notE)
qed

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

(* pabalagon manperjim josgomrom4 marfruman1 juacanrod pabbergue *)
lemma ejercicio_58:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "(p ⟶ q) ∨ ¬(p ⟶ q)" proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ ¬(p ⟶ q))"
have 2: "¬(p ⟶ q)" proof (rule notI)
assume "p ⟶ q"
hence 3: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
hence 4: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed
thus ?thesis proof (rule disjE)
assume "p ⟶ q" thus ?thesis by (rule disjI1)
next
assume 1: "¬(p ⟶ q)"
have "q ⟶ p" proof (rule impI)
assume 2: q
have 3: "p ⟶ q" proof (rule impI)
assume p show q using 2 .
qed
show p using 1 3 by (rule notE)
qed
thus ?thesis by (rule disjI2)
qed
qed

(* pabalagon gleherlop *)
lemma ejercicio_58_2:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "(p ∧ ¬q) ∧ (q ∧ ¬p)" by simp
hence "p ∧ ¬q" ..
hence 2: p ..
have "q ∧ ¬p" using 1 ..
hence 3: "¬p" ..
show False using 3 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_58_1:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume "¬ ((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "¬(p ⟶ q) ∧ ¬(q ⟶ p)" by (rule ejercicio_46_1)

have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
moreover {
assume "¬p"
hence "p ⟶ q" by (rule ejercicio_40_1)

have "¬(p ⟶ q)" using 1 by (rule conjunct1)
hence "False" using `p ⟶ q` by (rule notE)
}
ultimately show "False" by (rule disjE)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
qed

(* alfmarcua *)
lemma ejercicio_58_3:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
show "p ∨ ¬ p" by (rule ejercicio_52)
next
assume "¬p"
then have "p ⟶ q" by (rule ejercicio_40)
then show ?thesis by (rule disjI1)
next
assume "p"
then have "q ⟶ p" by (rule ejercicio_7)
then show ?thesis by (rule disjI2)
qed

end
</source>

Relación 6

2019-02-28T13:04:57Z

Jalonso:

<source lang="isabelle">
chapter {* R6: Deducción natural proposicional *}

theory R6_Deduccion_natural_proposicional
imports Main
begin

text {*
---------------------------------------------------------------------
El objetivo de esta relación es demostrar cada uno de los ejercicios
usando sólo las reglas básicas de deducción natural de la lógica
proposicional (sin usar el método auto).

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

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

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

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

section {* Implicaciones *}

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

(* pabalagon manperjim josgomrom4 cammonagu raffergon2 chrgencar
gleherlop giafus1 marfruman1 enrparalv pabbergue antramhur alikan
juacanrod hugrubsan *)
lemma ejercicio_1:
assumes 1: "p ⟶ q" and
2: "p"
shows "q"
proof -
show "q" using 1 2 by (rule mp)
qed

(* benber alfmarcua *)
lemma ejercicio_1_1:
assumes "p ⟶ q"
"p"
shows "q"
using assms by (rule mp)

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_2:
assumes 1: "p ⟶ q" and
2: "q ⟶ r" and
3: "p"
shows "r"
proof -
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed

(* benber *)
lemma ejercicio_2_1:
assumes "p ⟶ q"
"q ⟶ r"
"p"
shows "r"
proof -
have "q" using `p ⟶ q` `p` by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu gleherlop raffergon2
chrgencar giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_3:
assumes 1: "p ⟶ (q ⟶ r)" and
2: "p ⟶ q" and
3: "p"
shows "r"
proof -
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_3_1:
assumes "p ⟶ (q ⟶ r)"
"p ⟶ q"
"p"
shows "r"
proof -
have "q ⟶ r" using `p ⟶ (q ⟶ r)` `p` by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 cammonagu chrgencar raffergon2
gleherlop giafus1 marfruman1 alfmarcua enrparalv pabbergue antramhur
alikan juacanrod hugrubsan *)
lemma ejercicio_4:
assumes 1: "p ⟶ q" and
2: "q ⟶ r"
shows "p ⟶ r"
proof -
{ assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
have 5: "r" using 2 4 by (rule mp)}
thus "p ⟶ r" by (rule impI)
qed

(* benber *)
lemma ejercicio_4_1:
assumes "p ⟶ q"
"q ⟶ r"
shows "p ⟶ r"
proof
assume p
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim raffergon2 giafus1 gleherlop marfruman1 alfmarcua
enrparalv chrgencar pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_5:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
show "r" using 4 2 by (rule mp)
qed
qed

(* benber josgomrom4 juacanrod cammonagu *)
lemma ejercicio_5_1:
assumes "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof
assume "q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
thus "r" using `q` by (rule mp)
qed
qed

(* pabalagon *)
lemma ejercicio_5_2:
assumes 1: "p ⟶ (q ⟶ r)"
shows "q ⟶ (p ⟶ r)"
proof -
{ assume 2: "q"
{ assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "r" using 4 2 by (rule mp)}
hence "p ⟶ r" by (rule impI)
}
thus "q ⟶ (p ⟶ r)" by (rule impI)
qed

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

(* pabalagon manperjim cammonagu chrgencar raffergon2 gleherlop giafus1
marfruman1 alfmarcua enrparalv pabbergue antramhur alikan juacanrod
hugrubsan *)
lemma ejercicio_6:
assumes 1: "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed

(* benber josgomrom4 *)
lemma ejercicio_6_1:
assumes "p ⟶ (q ⟶ r)"
shows "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ⟶ q` `p` have "q" by (rule mp)
ultimately show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 gleherlop
marfruman1 enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_7:
assumes 1: "p"
shows "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed

(* benber cammonagu juacanrod chrgencar *)
lemma ejercicio_7_1:
assumes "p"
shows "q ⟶ p"
proof
show "p" using `p` .
qed

(* alfmarcua *)
lemma ejercicio_7_2:
assumes "p"
shows "q ⟶ p"
using assms by (rule impI)

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

(* pabalagon manperjim josgomrom4 raffergon2 giafus1 marfruman1
enrparalv pabbergue antramhur alikan hugrubsan *)
lemma ejercicio_8:
"p ⟶ (q ⟶ p)"
proof (rule impI)
assume 1: "p"
show "q ⟶ p"
proof (rule impI)
assume 2: "q"
show "p" using 1 by this
qed
qed

(* benber cammonagu gleherlop chrgencar juacanrod alfmarcua *)
lemma ejercicio_8_1:
"p ⟶ (q ⟶ p)"
using ejercicio_7_1 by (rule impI)

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

(* pabalagon manperjim raffergon2 giafus1 marfruman1 alfmarcua enrparalv
gleherlop antramhur alikan hugrubsan *)
lemma ejercicio_9:
assumes 1: "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "q ⟶ r"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q" using 1 3 by (rule mp)
show "r" using 2 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu chrgencar juacanrod pabbergue *)
lemma ejercicio_9_1:
assumes "p ⟶ q"
shows "(q ⟶ r) ⟶ (p ⟶ r)"
proof
assume "q ⟶ r"
show "p ⟶ r"
proof
assume "p"
with `p ⟶ q` have "q" by (rule mp)
with `q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop alfmarcua
enrparalv pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_10:
assumes 1: "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof (rule impI)
assume 2: "r"
show "q ⟶ (p ⟶ s)"
proof (rule impI)
assume 3: "q"
show "p ⟶ s"
proof (rule impI)
assume 4: "p"
have 5: "q ⟶ (r ⟶ s)" using 1 4 by (rule mp)
have 6: "r ⟶ s" using 5 3 by (rule mp)
show "s" using 6 2 by (rule mp)
qed
qed
qed

(* benber josgomrom4 cammonagu chrgencar giafus1 *)
lemma ejercicio_10_1:
assumes "p ⟶ (q ⟶ (r ⟶ s))"
shows "r ⟶ (q ⟶ (p ⟶ s))"
proof
assume "r"
show "q ⟶ (p ⟶ s)"
proof
assume "q"
show "p ⟶ s"
proof
assume "p"
with `p ⟶ (q ⟶ (r ⟶ s))`
have "q ⟶ (r ⟶ s)" by (rule mp)
hence "r ⟶ s" using `q` by (rule mp)
thus "s" using `r` by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim josgomrom4 gleherlop cammonagu giafus1 alfmarcua
chrgencar pabbergue alikan juacanrod hugrubsan *)
lemma ejercicio_11:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)" using 1 ejercicio_6 by simp
qed

(* pabalagon raffergon2 marfruman1 enrparalv antramhur *)
lemma ejercicio_11_2:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof (rule impI)
assume 1: "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof (rule impI)
assume 2: "p ⟶ q"
show "p ⟶ r"
proof (rule impI)
assume 3: "p"
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 3 by (rule mp)
show "r" using 4 5 by (rule mp)
qed
qed
qed

(* benber *)
lemma ejercicio_11_1:
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"
proof
assume "p ⟶ (q ⟶ r)"
show "(p ⟶ q) ⟶ (p ⟶ r)"
proof
assume "p ⟶ q"
show "p ⟶ r"
proof
assume p
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover have "q" using `p ⟶ q` `p` by (rule mp)
ultimately show r by (rule mp)
qed
qed
qed

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

(* pabalagon manperjim raffergon2 marfruman1 gleherlop enrparalv
pabbergue antramhur alikan juacanrod hugrubsan *)
lemma ejercicio_12:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ⟶ q"
proof (rule impI)
assume 5: "p"
show "q" using 3 by this
qed
show "r" using 1 4 by (rule mp)
qed
qed

(* benber josgomrom4 cammonagu giafus1 alfmarcua chrgencar *)
lemma ejercicio_12_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed
qed

section {* Conjunciones *}

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

(* pabalagon *)
lemma ejercicio_13:
assumes "p"
"q"
shows "p ∧ q"
using assms(1, 2) by (rule conjI)

(* benber manperjim josgomrom4 cammonagu raffergon2 marfruman1 alfmarcua
enrparalv chrgencar gleherlop pabbergue antramhur juacanrod hugrubsan
alikan *)
lemma ejercicio_13_1:
assumes "p"
"q"
shows "p ∧ q"
using assms by (rule conjI)

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

(* pabalagon josgomrom4 *)
lemma ejercicio_14:
assumes "p ∧ q"
shows "p"
using assms(1) by (rule conjunct1)

(* benber manperjim cammonagu raffergon2 marfruman1 alfmarcua enrparalv
chrgencar pabbergue gleherlop antramhur hugrubsan juacanrod alikan *)
lemma ejercicio_14_1:
assumes "p ∧ q"
shows "p"
using assms by (rule conjunct1)

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

(* pabalagon manperjim juacanrod josgomrom4 *)
lemma ejercicio_15:
assumes "p ∧ q"
shows "q"
using assms(1) by (rule conjunct2)

(* benber cammonagu raffergon2 marfruman1 alfmarcua enrparalv chrgencar
pabbergue antramhur gleherlop hugrubsan alikan *)
lemma ejercicio_15_1:
assumes "p ∧ q"
shows "q"
using assms by (rule conjunct2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammmonagu enrparalv chrgencar gleherlop pabbergue antramhur
hugrubsan alikan juacanrod cammonagu *)
lemma ejercicio_16:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof -
have 1: "p" using assms(1) by (rule conjunct1)
have 2: "q ∧ r" using assms(1) by (rule conjunct2)
have 3: "q" using 2 by (rule conjunct1)
have 4: "r" using 2 by (rule conjunct2)
have 5: "p ∧ q" using 1 3 by (rule conjI)
show "(p ∧ q) ∧ r" using 5 4 by (rule conjI)
qed

(* benber *)
lemma ejercicio_16_1:
assumes "p ∧ (q ∧ r)"
shows "(p ∧ q) ∧ r"
proof - (* TODO? *)
have "q ∧ r" using assms by (rule conjunct2)
have "p" using assms by (rule conjunct1)
moreover have "q" using `q ∧ r` by (rule conjunct1)
ultimately have "p ∧ q" by (rule conjI)
moreover have "r" using `q ∧ r` by (rule conjunct2)
ultimately show "(p ∧ q) ∧ r" by (rule conjI)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv hugrubsan
juacanrod alikan *)
lemma ejercicio_17:
assumes 1: "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have 2: "r" using 1 by (rule conjunct2)
have 3: "p ∧ q" using 1 by (rule conjunct1)
have 4: "p" using 3 by (rule conjunct1)
have 5: "q" using 3 by (rule conjunct2)
have 6: "q ∧ r" using 5 2 by (rule conjI)
show ?thesis using 4 6 by (rule conjI)
qed

(* benber *)
lemma ejercicio_17_1:
assumes "(p ∧ q) ∧ r"
shows "p ∧ (q ∧ r)"
proof -
have "p ∧ q" using assms by (rule conjunct1)
have "p" using `p ∧ q` by (rule conjunct1)
moreover have "q ∧ r"
proof (rule conjI)
show "q" using `p ∧ q` by (rule conjunct2)
next
show "r" using assms by (rule conjunct2)
qed
ultimately show ?thesis by (rule conjI)
qed

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

(* pabalagon raffergon2 marfruman1 juacanrod alikan*)
lemma ejercicio_18:
assumes "p ∧ q"
shows "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using assms(1) by (rule conjunct2)
qed

(* benber manperjim josgomrom4 cammonagu alfmarcua chrgencar pabbergue
gleherlop antramhur enrparalv hugrubsan *)
lemma ejercicio_18_1:
assumes "p ∧ q"
shows "p ⟶ q"
proof
show "q" using assms by (rule conjunct2)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_19:
assumes 1: "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof (rule impI)
assume 2: "p"
have 3: "p ⟶ q" using 1 by (rule conjunct1)
have 4: "p ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 3 2 by (rule mp)
have 6: "r" using 4 2 by (rule mp)
show "q ∧ r" using 5 6 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_19_1:
assumes "(p ⟶ q) ∧ (p ⟶ r)"
shows "p ⟶ q ∧ r"
proof
assume p
show "q ∧ r"
proof
have "p ⟶ q" using assms by (rule conjunct1)
thus "q" using `p` by (rule mp)
next
have "p ⟶ r" using assms by (rule conjunct2)
thus "r" using `p` by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_20:
assumes 1: "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof (rule conjI)
show "p ⟶ q"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "q" using 3 by (rule conjunct1)
qed
show "p ⟶ r"
proof (rule impI)
assume 2: "p"
have 3: "q ∧ r" using 1 2 by (rule mp)
show 4: "r" using 3 by (rule conjunct2)
qed
qed

(* benber *)
lemma ejercicio_20_1:
assumes "p ⟶ q ∧ r"
shows "(p ⟶ q) ∧ (p ⟶ r)"
proof
show "p ⟶ q"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "q" by (rule conjunct1)
qed
next
show "p ⟶ r"
proof
assume "p"
with assms have "q ∧ r" by (rule mp)
thus "r" by (rule conjunct2)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
cammonagu chrgencar pabbergue gleherlop antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_21:
assumes 1: "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p" using 2 by (rule conjunct1)
have 4: "q ⟶ r" using 1 3 by (rule mp)
have 5: "q" using 2 by (rule conjunct2)
show "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_21_1:
assumes "p ⟶ (q ⟶ r)"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "p" by (rule conjunct1)
with `p ⟶ (q ⟶ r)` have "q ⟶ r" by (rule mp)
moreover from `p ∧ q` have "q" by (rule conjunct2)
ultimately show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_22:
assumes 1: "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof (rule impI)
assume 2: "p"
show "q ⟶ r"
proof (rule impI)
assume 3: "q"
have 4: "p ∧ q" using 2 3 by (rule conjI)
show "r" using 1 4 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_22_1:
assumes "p ∧ q ⟶ r"
shows "p ⟶ (q ⟶ r)"
proof
assume "p"
show "q ⟶ r"
proof
assume "q"
with `p` have "p ∧ q" by (rule conjI)
with `p ∧ q ⟶ r` show "r" by (rule mp)
qed
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_23:
assumes 1: "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof (rule impI)
assume 2: "p ∧ q"
have 3: "p ⟶ q"
proof (rule impI)
assume "p"
show "q" using 2 by (rule conjunct2)
qed
show "r" using 1 3 by (rule mp)
qed

(* benber cammonagu *)
lemma ejercicio_23_1:
assumes "(p ⟶ q) ⟶ r"
shows "p ∧ q ⟶ r"
proof
assume "p ∧ q"
hence "q" by (rule conjunct2)
hence "p ⟶ q" by (rule impI)
with `(p ⟶ q) ⟶ r` show "r" by (rule mp)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv hugrubsan juacanrod
cammonagu alikan *)
lemma ejercicio_24:
assumes 1: "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof (rule impI)
assume 2: "p ⟶ q"
have 3: "p" using 1 by (rule conjunct1)
have 4: "q ⟶ r" using 1 by (rule conjunct2)
have 5: "q" using 2 3 by (rule mp)
show 6: "r" using 4 5 by (rule mp)
qed

(* benber *)
lemma ejercicio_24_1:
assumes "p ∧ (q ⟶ r)"
shows "(p ⟶ q) ⟶ r"
proof
have "q ⟶ r" using assms by (rule conjunct2)
assume "p ⟶ q"
moreover have "p" using assms by (rule conjunct1)
ultimately have "q" by (rule mp)
with `q ⟶ r` show r by (rule mp)
qed

section {* Disyunciones *}

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

(* pabalagon manperjim josgomrom4 benber cammonagu raffergon2 marfruman1
alfmarcua chrgencar gleherlop pabbergue antramhur enrparalv juacanrod
hugrubsan alikan *)
lemma ejercicio_25:
assumes "p"
shows "p ∨ q"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim josgomrom4 benber cammonagu marfruman1 alfmarcua
chrgencar pabbergue gleherlop antramhur enrparalv juacanrod hugrubsan
alikan *)
lemma ejercicio_26:
assumes "q"
shows "p ∨ q"
using assms(1) by (rule disjI2)

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
pabbergue antramhur enrparalv juacanrod hugrubsan cammonagu alikan *)
lemma ejercicio_27:
assumes 1: "p ∨ q"
shows "q ∨ p"
using 1 proof (rule disjE)
assume 2: "p" thus "q ∨ p" by (rule disjI2)
next
assume 3: "q" thus "q ∨ p" by (rule disjI1)
qed

(* benber alfmarcua gleherlop *)
lemma ejercicio_27_1:
assumes "p ∨ q"
shows "q ∨ p"
proof -
have "p ∨ q" using assms .
moreover have "p ⟹ q ∨ p" by (rule disjI2)
moreover have "q ⟹ q ∨ p" by (rule disjI1)
ultimately show "q ∨ p" by (rule disjE)
qed

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

(* pabalagon manperjim josgomrom4 raffergon2 marfruman1 chrgencar
gleherlop alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan
cammonagu alikan *)
lemma ejercicio_28:
assumes 1: "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof (rule impI)
assume 2: "p ∨ q" show "p ∨ r" using 2
proof (rule disjE)
assume 3: p thus "p ∨ r" by (rule disjI1)
next
assume 4: q have r using 1 4 by (rule mp)
thus "p ∨ r" by (rule disjI2)
qed
qed

(* benber *)
lemma ejercicio_28_1:
assumes "q ⟶ r"
shows "p ∨ q ⟶ p ∨ r"
proof
assume "p ∨ q"
moreover have "p ⟹ p ∨ r" by (rule disjI1)
moreover have "q ⟹ p ∨ r"
proof (rule disjI2)
assume "q"
with `q ⟶ r` show "r" by (rule mp)
qed
ultimately show "p ∨ r" by (rule disjE)
qed

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

(* pabalagon juacanrod marfruman1 *)
lemma ejercicio_29:
assumes 1: "p ∨ p"
shows "p"
using 1 proof (rule disjE)
assume "p" thus "p" .
next
assume "p" thus "p" .
qed

(* benber manperjim cammonagu josgomrom4 raffergon2 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv hugrubsan alikan *)
lemma ejercicio_29_1:
assumes "p ∨ p"
shows "p"
using assms by (rule disjE)

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

(* pabalagon manperjim benber josgomrom4 raffergon2 marfruman1
chrgencar alfmarcua pabbergue gleherlop antramhur enrparalv hugrubsan
juacanrod cammonagu alikan *)
lemma ejercicio_30:
assumes "p"
shows "p ∨ p"
using assms(1) by (rule disjI1)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_31:
assumes 1: "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r" (is "?R")
using 1 proof (rule disjE)
assume "p" hence "p ∨ q" by (rule disjI1)
thus ?R by (rule disjI1)
next
assume "q ∨ r" thus ?R
proof (rule disjE)
assume "q" hence "p ∨ q" by (rule disjI2)
thus "(p ∨ q) ∨ r" by (rule disjI1)
next
assume "r" thus ?thesis by (rule disjI2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_31_1:
assumes "p ∨ (q ∨ r)"
shows "(p ∨ q) ∨ r"
proof -
have "p ∨ (q ∨ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "q ∨ r"
moreover {
assume "q"
hence "p ∨ q" by (rule disjI2)
hence "(p ∨ q) ∨ r" by (rule disjI1)
}
moreover {
assume "r"
hence "(p ∨ q) ∨ r" by (rule disjI2)
}
ultimately have "(p ∨ q) ∨ r" by (rule disjE)
}
ultimately show "(p ∨ q) ∨ r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_32:
assumes 1: "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
using 1 proof (rule disjE)
assume "p ∨ q" thus ?thesis
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume q hence "q ∨ r" by (rule disjI1)
thus ?thesis by (rule disjI2)
qed
next
assume r hence "q ∨ r" by (rule disjI2)
thus ?thesis by (rule disjI2)
qed

(* benber cammonagu *)
lemma ejercicio_32_1:
assumes "(p ∨ q) ∨ r"
shows "p ∨ (q ∨ r)"
proof -
have "(p ∨ q) ∨ r" using assms .
moreover {
assume "p ∨ q"
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
hence "q ∨ r" by (rule disjI1)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
moreover {
assume "r"
hence "q ∨ r" by (rule disjI2)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar gleherlop
alfmarcua pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_33:
assumes 1: "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have 2: p using 1 by (rule conjunct1)
show ?thesis
proof (rule disjE)
assume 3: q have "p ∧ q" using 2 3 by (rule conjI)
thus ?thesis by (rule disjI1)
next
assume 4: r have "p ∧ r" using 2 4 by (rule conjI)
thus ?thesis by (rule disjI2)
next
show "q ∨ r" using 1 by (rule conjunct2)
qed
qed

(* benber cammonagu *)
lemma ejercicio_33_1:
assumes "p ∧ (q ∨ r)"
shows "(p ∧ q) ∨ (p ∧ r)"
proof -
have "p" using assms by (rule conjunct1)
have "q ∨ r" using assms by (rule conjunct2)
moreover {
assume "q"
with `p` have "p ∧ q" by (rule conjI)
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `p` have "p ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_34:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
using assms(1) proof (rule disjE)
assume 2: "p ∧ q" hence q by (rule conjunct2)
hence 3: "q ∨ r" by (rule disjI1)
have p using 2 by (rule conjunct1)
thus ?thesis using 3 by (rule conjI)
next
assume 4: "p ∧ r" hence r by (rule conjunct2)
hence 5: "q ∨ r" by (rule disjI2)
have p using 4 by (rule conjunct1)
thus ?thesis using 5 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_34_1:
assumes "(p ∧ q) ∨ (p ∧ r)"
shows "p ∧ (q ∨ r)"
proof -
have "(p ∧ q) ∨ (p ∧ r)" using assms .
moreover {
assume "p ∧ q"
hence "p" by (rule conjunct1)
moreover {
have "q" using `p ∧ q` by (rule conjunct2)
hence "q ∨ r" by (rule disjI1)
}
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "p ∧ r"
hence "p" by (rule conjunct1)
moreover {
have "r" using `p ∧ r` by (rule conjunct2)
hence "q ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_35:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
using assms(1) proof (rule disjE)
assume 1: p hence 2: "p ∨ r" by (rule disjI1)
have "p ∨ q" using 1 by (rule disjI1)
thus ?thesis using 2 by (rule conjI)
next
assume 3: "q ∧ r" hence r by (rule conjunct2)
hence 4: "p ∨ r" by (rule disjI2)
have q using 3 by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
thus ?thesis using 4 by (rule conjI)
qed

(* benber cammonagu *)
lemma ejercicio_35_1:
assumes "p ∨ (q ∧ r)"
shows "(p ∨ q) ∧ (p ∨ r)"
proof -
have "p ∨ (q ∧ r)" using assms .
moreover {
assume "p"
hence "p ∨ q" by (rule disjI1)
moreover have "p ∨ r" using `p` by (rule disjI1)
ultimately have ?thesis by (rule conjI)
}
moreover {
assume "q ∧ r"
{
have "q" using `q ∧ r` by (rule conjunct1)
hence "p ∨ q" by (rule disjI2)
}
moreover {
have "r" using `q ∧ r` by (rule conjunct2)
hence "p ∨ r" by (rule disjI2)
}
ultimately have ?thesis by (rule conjI)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 chrgencar alfmarcua
gleherlop pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_36:
assumes 1: "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have 2: "p ∨ q" using 1 by (rule conjunct1)
have 3: "p ∨ r" using 1 by (rule conjunct2)
show ?thesis using 2
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 4: q show ?thesis using 3
proof (rule disjE)
assume p thus ?thesis by (rule disjI1)
next
assume 5: r have "q ∧ r" using 4 5 by (rule conjI)
thus ?thesis by (rule disjI2)
qed
qed
qed

(* benber cammonagu *)
lemma ejercicio_36_1:
assumes "(p ∨ q) ∧ (p ∨ r)"
shows "p ∨ (q ∧ r)"
proof -
have "p ∨ q" using assms by (rule conjunct1)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "q"
have "p ∨ r" using assms by (rule conjunct2)
moreover {
assume "p"
hence ?thesis by (rule disjI1)
}
moreover {
assume "r"
with `q` have "q ∧ r" by (rule conjI)
hence ?thesis by (rule disjI2)
}
ultimately have ?thesis by (rule disjE)
}
ultimately show ?thesis by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_37:
assumes 1: "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof (rule impI)
have 2: "p ⟶ r" using 1 by (rule conjunct1)
have 3: "q ⟶ r" using 1 by (rule conjunct2)
assume 4: "p ∨ q" show "r" using 4
proof (rule disjE)
assume 5: "p" show "r" using 2 5 by (rule mp)
next
assume 6: "q" show "r" using 3 6 by (rule mp)
qed
qed

(* benber cammonagu *)
lemma ejercicio_37_1:
assumes "(p ⟶ r) ∧ (q ⟶ r)"
shows "p ∨ q ⟶ r"
proof
assume "p ∨ q"
moreover {
have "p ⟶ r" using assms by (rule conjunct1)
moreover assume "p"
ultimately have "r" by (rule mp)
}
moreover {
have "q ⟶ r" using assms by (rule conjunct2)
moreover assume "q"
ultimately have "r" by (rule mp)
}
ultimately show "r" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
pabbergue antramhur enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_38:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof (rule conjI)
show "p ⟶ r"
proof (rule impI)
assume "p" hence 1: "p ∨ q" by (rule disjI1)
show "r" using assms(1) 1 by (rule mp)
qed
next
show "q ⟶ r"
proof (rule impI)
assume q hence 2: "p ∨ q" by (rule disjI2)
show r using assms(1) 2 by (rule mp)
qed
qed

(* benber cammonagu*)
lemma ejercicio_38_1:
assumes "p ∨ q ⟶ r"
shows "(p ⟶ r) ∧ (q ⟶ r)"
proof
show "p ⟶ r"
proof
assume "p"
hence "p ∨ q" by (rule disjI1)
with assms show "r" by (rule mp)
qed
next
show "q ⟶ r"
proof
assume "q"
hence "p ∨ q" by (rule disjI2)
with assms show "r" by (rule mp)
qed
qed

section {* Negaciones *}

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

(* pabalagon manperjim benber josgomrom4 raffergon2 gleherlop
marfruman1 chrgencar alfmarcua pabbergue enrparalv juacanrod
hugrubsan cammonagu alikan *)
lemma ejercicio_39:
assumes "p"
shows "¬¬p"
using assms(1) by (rule notnotI)

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua pabbergue
gleherlop juacanrod enrparalv hugrubsan alikan *)
lemma ejercicio_40:
assumes 1: "¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: p show q using 1 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_40_1:
assumes "¬p"
shows "p ⟶ q"
proof
assume "p"
with `¬p` show "q" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_41:
assumes 1: "p ⟶ q"
shows "¬q ⟶ ¬p"
proof (rule impI)
assume 2: "¬q" show "¬p" using 1 2 by (rule mt)
qed

(* benber cammonagu *)
lemma ejercicio_41_1:
assumes "p ⟶ q"
shows "¬q ⟶ ¬p"
proof
assume "¬q"
with `p ⟶ q` show "¬p" by (rule mt)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_42:
assumes "p∨q"
"¬q"
shows "p"
using assms(1) proof (rule disjE)
assume "p" thus "p" .
next
assume 2: "q" show "p" using assms(2) 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_42_1:
assumes "p∨q"
"¬q"
shows "p"
proof -
note `p ∨ q`
moreover have "p ⟹ p" .
moreover {
assume "q"
with `¬q` have "p" by (rule notE)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 alfmarcua
pabbergue gleherlop enrparalv juacanrod hugrubsan alikan *)
lemma ejercicio_43:
assumes "p ∨ q"
"¬p"
shows "q"
using assms(1) proof (rule disjE)
assume 1: "p" show "q" using assms(2) 1 by (rule notE)
next
assume "q" thus "q" .
qed

(* benber cammonagu*)
lemma ejercicio_43_1:
assumes "p ∨ q"
"¬p"
shows "q"
proof -
note `p ∨ q`
moreover {
assume "p"
with `¬p` have "q" by (rule notE)
}
moreover have "q ⟹ q" .
ultimately show "q" by (rule disjE)
qed

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

(* pabalagon manperjim gleherlop josgomrom4 marfruman1 pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_44:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof (rule notI)
assume 1: "¬p ∧ ¬q" hence 2: "¬p" by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
show "False"
using assms(1) proof (rule disjE)
assume 4: "p" show ?thesis using 2 4 by (rule notE)
next
assume 5: "q" show ?thesis using 3 5 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_44_1:
assumes "p ∨ q"
shows "¬(¬p ∧ ¬q)"
proof
assume "¬p ∧ ¬q"
note `p ∨ q`
moreover {
from `¬p ∧ ¬q` have "¬p" by (rule conjunct1)
moreover assume "p"
ultimately have "False" by (rule notE)
}
moreover {
from `¬p ∧ ¬q` have "¬q" by (rule conjunct2)
moreover assume "q"
ultimately have "False" by (rule notE)
}
ultimately show "False" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_45:
assumes 1: "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof (rule notI)
assume 2: "¬p ∨ ¬q" have 3: "p" using 1 by (rule conjunct1)
have 4: "q" using 1 by (rule conjunct2)
show "False" using 2
proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_45_1:
assumes "p ∧ q"
shows "¬(¬p ∨ ¬q)"
proof
assume "¬p ∨ ¬q"
moreover {
assume "¬p"
moreover have "p" using `p ∧ q` by (rule conjunct1)
ultimately have "False" by (rule notE)
}
moreover {
assume "¬q"
moreover have "q" using `p ∧ q` by (rule conjunct2)
ultimately have "False" by (rule notE)
}
ultimately show False by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop pabbergue
juacanrod hugrubsan alikan *)
lemma ejercicio_46:
assumes 1: "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
show "¬p"
proof (rule notI)
assume p hence 2: "p ∨ q" by (rule disjI1)
show False using 1 2 by (rule notE)
qed
show "¬q"
proof (rule notI)
assume q hence 3: "p ∨ q" by (rule disjI2)
show False using 1 3 by (rule notE)
qed
qed

(* benber cammmonagu *)
lemma ejercicio_46_1:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof
show "¬p"
proof (rule ccontr)
assume "¬¬p"
hence "p" by (rule notnotD)
hence "p ∨ q" by (rule disjI1)
with assms show "False" by (rule notE)
qed
next
show "¬q"
proof (rule ccontr)
assume "¬¬q"
hence "q" by (rule notnotD)
hence "p ∨ q" by (rule disjI2)
with assms show "False" by (rule notE)
qed
qed

(* alfmarcua *)
lemma ejercicio_46_2:
assumes "¬(p ∨ q)"
shows "¬p ∧ ¬q"
proof (rule conjI)
have "p ⟹ p ∨ q" by (rule disjI1)
then have "p ⟶ p ∨ q" by (rule impI)
then show "¬ p" using assms by (rule mt)
next
have "q ⟹ p ∨ q" by (rule disjI2)
then have "q ⟶ p ∨ q" by (rule impI)
then show "¬ q" using assms by (rule mt)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbregue juacanrod
hugrubsan alikan *)
lemma ejercicio_47:
assumes 1: "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have 2: "¬p" using 1 by (rule conjunct1)
have 3: "¬q" using 1 by (rule conjunct2)
assume 4: "p ∨ q"
show False
using 4 proof (rule disjE)
assume 5: p show ?thesis using 2 5 by (rule notE)
next
assume 6: q show ?thesis using 3 6 by (rule notE)
qed
qed

(* benber gleherlop cammonagu*)
lemma ejercicio_47_1:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof
assume "p ∨ q"
hence "¬(¬p ∧ ¬q)" by (rule ejercicio_44_1)
thus "False" using assms by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_47_2:
assumes "¬p ∧ ¬q"
shows "¬(p ∨ q)"
proof (rule notI)
have "¬ p" using assms by (rule conjunct1)
have "¬ q" using assms by (rule conjunct2)
assume "p ∨ q"
then have "q" using `¬ p` by (rule ejercicio_43)
show False using `¬ q` `q` by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 pabbergue juacanrod
hugrubsan alikan *)
lemma ejercicio_48:
assumes 1: "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof (rule notI)
assume 2: "p ∧ q" hence 3: p by (rule conjunct1)
have 4: q using 2 by (rule conjunct2)
show False
using 1 proof (rule disjE)
assume "¬p" thus ?thesis using 3 by (rule notE)
next
assume "¬q" thus ?thesis using 4 by (rule notE)
qed
qed

(* benber alfmarcua gleherlop cammonagu *)
lemma ejercicio_48_1:
assumes "¬p ∨ ¬q"
shows "¬(p ∧ q)"
proof
assume "p ∧ q"
hence "¬(¬p ∨ ¬q)" by (rule ejercicio_45_1)
thus "False" using assms by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcu gleherlop
hugrubsan juacanrod cammonagu alikan *)
lemma ejercicio_49:
"¬(p ∧ ¬p)"
proof (rule notI)
assume 1: "p ∧ ¬p" hence 2: p by (rule conjunct1)
have "¬p" using 1 by (rule conjunct2)
thus "False" using 2 by (rule notE)
qed

(* benber *)
lemma ejercicio_49_1:
"¬(p ∧ ¬p)"
proof
assume "p ∧ ¬p"
hence "¬p" by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "False" by (rule notE)
qed

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

(* pabalagon manperjim raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan alikan *)
lemma ejercicio_50:
assumes 1: "p ∧ ¬p"
shows "q"
proof (rule notE)
show p using 1 by (rule conjunct1)
show "¬p" using 1 by (rule conjunct2)
qed

(* benber cammonagu*)
lemma ejercicio_50_1:
assumes "p ∧ ¬p"
shows "q"
proof -
have "¬p" using `p ∧ ¬p` by (rule conjunct2)
moreover have "p" using `p ∧ ¬p` by (rule conjunct1)
ultimately show "q" by (rule notE)
qed

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

(* pabalagon manperjim benber raffergon2 josgomrom4 marfruman1 gleherlop
alfmarcua enrparalv pabbergue juacanrod hugrubsan cammmonagu alikan *)
lemma ejercicio_51:
assumes "¬¬p"
shows "p"
using assms(1) by (rule notnotD)

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

(* pabalagon manperjim marfruman1 josgomrom4 juacanrod pabbergue alikan *)
lemma ejercicio_52:
"p ∨ ¬p"
proof (rule ccontr)
assume 1: "¬(p ∨ ¬p)"
have 2: "¬p" proof (rule notI)
assume p hence 3: "p ∨ ¬p" by (rule disjI1)
show "False" using 1 3 by (rule notE)
qed
have 4: "p ∨ ¬p" using 2 by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_52_1:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
hence "¬p ∧ ¬¬p" by (rule ejercicio_46_1)
hence "¬p" by (rule conjunct1)
moreover {
have "¬¬p" using `¬p ∧ ¬¬p` by (rule conjunct2)
hence "p" by (rule notnotD)
}
ultimately show "False" by (rule notE)
qed

(* alfmarcua *)
lemma ejercicio_52_2:
"p ∨ ¬p"
proof (rule ccontr)
assume "¬ (p ∨ ¬ p)"
then have "¬ p ∧ ¬¬ p" by (rule ejercicio_46)
then show False by (rule ejercicio_50)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 alfmarcua gleherlop
juacanrod pabbergue *)
lemma ejercicio_53:
"((p ⟶ q) ⟶ p) ⟶ p"
proof (rule impI)
assume 1: "(p ⟶ q) ⟶ p"
show p proof (rule ccontr)
assume 2: "¬p"
have 3: "¬(p ⟶ q)" using 1 2 by (rule mt)
have 4: "p ⟶ q" proof (rule impI)
assume 5: p show q using 2 5 by (rule notE)
qed
show False using 3 4 by (rule notE)
qed
qed

(* benber cammonagu *)
lemma ejercicio_53_1:
"((p ⟶ q) ⟶ p) ⟶ p"
proof
assume "(p ⟶ q) ⟶ p"
have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover have "p ⟹ p" .
moreover {
assume "¬ p"
hence "p ⟶ q" by (rule ejercicio_40_1)
with `(p ⟶ q) ⟶ p` have "p" by (rule mp)
}
ultimately show "p" by (rule disjE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_54:
assumes 1: "¬q ⟶ ¬p"
shows "p ⟶ q"
proof (rule impI)
assume 2: "p" hence 3: "¬¬p" by (rule notnotI)
have "¬¬q" using 1 3 by (rule mt)
thus "q" by (rule notnotD)
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_54_1:
assumes "¬q ⟶ ¬p"
shows "p ⟶ q"
proof
assume "p"
hence "¬¬p" by (rule notnotI)
with assms have "¬¬q" by (rule mt)
thus "q" by (rule notnotD)
qed

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

(* pabalagon marfruman1*)
lemma ejercicio_55:
assumes 1: "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume 2: "¬(p ∨ q)"
have 3: "p"
proof (rule ccontr)
assume 4: "¬p"
have 5: "q"
proof (rule ccontr)
assume 6: "¬q" have 7: "¬p ∧ ¬q" using 4 6 by (rule conjI)
show False using 1 7 by (rule notE)
qed
have 8: "p ∨ q" using 5 by (rule disjI2)
show False using 2 8 by (rule notE)
qed
have 9: "p ∨ q" using 3 by (rule disjI1)
show False using 2 9 by (rule notE)
qed

(* benber alfmarcua josgomrom4 manperjim pabbergue juacanrod cammonagu *)
lemma ejercicio_55_1:
assumes "¬(¬p ∧ ¬q)"
shows "p ∨ q"
proof (rule ccontr)
assume "¬(p ∨ q)"
hence "¬p ∧ ¬q" by (rule ejercicio_46_1)
with assms show False by (rule notE)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_56:
assumes 1: "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof (rule conjI)
show 3: p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 1 4 by (rule notE)
qed
show 5: q
proof (rule ccontr)
assume "¬q" hence 6: "¬p ∨ ¬q" by (rule disjI2)
show False using 1 6 by (rule notE)
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_56_1:
assumes "¬(¬p ∨ ¬q)"
shows "p ∧ q"
proof -
have "¬¬p ∧ ¬¬q" using assms by (rule ejercicio_46_1)
hence "¬¬p" by (rule conjunct1)
hence "p" by (rule notnotD)
moreover {
have "¬¬q" using `¬¬p ∧ ¬¬q` by (rule conjunct2)
hence "q" by (rule notnotD)
}
ultimately show "p ∧ q" by (rule conjI)
qed

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

(* pabalagon manperjim marfruman1 josgomrom4 gleherlop juacanrod
pabbergue *)
lemma ejercicio_57:
assumes 1: "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume 2: "¬(¬p ∨ ¬q)"
show False using 1
proof (rule notE)
show 3: "p ∧ q"
proof (rule conjI)
show p
proof (rule ccontr)
assume "¬p" hence 4: "¬p ∨ ¬q" by (rule disjI1)
show False using 2 4 by (rule notE)
qed
next
show q
proof (rule ccontr)
assume "¬q" hence 5: "¬p ∨ ¬q" by (rule disjI2)
show False using 2 5 by (rule notE)
qed
qed
qed
qed

(* benber alfmarcua cammonagu *)
lemma ejercicio_57_1:
assumes "¬(p ∧ q)"
shows "¬p ∨ ¬q"
proof (rule ccontr)
assume "¬(¬p ∨ ¬q)"
hence "p ∧ q" by (rule ejercicio_56_1)
with assms show "False" by (rule notE)
qed

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

(* pabalagon manperjim josgomrom4 marfruman1 juacanrod pabbergue *)
lemma ejercicio_58:
"(p ⟶ q) ∨ (q ⟶ p)"
proof -
have "(p ⟶ q) ∨ ¬(p ⟶ q)" proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ ¬(p ⟶ q))"
have 2: "¬(p ⟶ q)" proof (rule notI)
assume "p ⟶ q"
hence 3: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI1)
show False using 1 3 by (rule notE)
qed
hence 4: "(p ⟶ q) ∨ ¬(p ⟶ q)" by (rule disjI2)
show "False" using 1 4 by (rule notE)
qed
thus ?thesis proof (rule disjE)
assume "p ⟶ q" thus ?thesis by (rule disjI1)
next
assume 1: "¬(p ⟶ q)"
have "q ⟶ p" proof (rule impI)
assume 2: q
have 3: "p ⟶ q" proof (rule impI)
assume p show q using 2 .
qed
show p using 1 3 by (rule notE)
qed
thus ?thesis by (rule disjI2)
qed
qed

(* pabalagon gleherlop *)
lemma ejercicio_58_2:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume 1: "¬((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "(p ∧ ¬q) ∧ (q ∧ ¬p)" by simp
hence "p ∧ ¬q" ..
hence 2: p ..
have "q ∧ ¬p" using 1 ..
hence 3: "¬p" ..
show False using 3 2 by (rule notE)
qed

(* benber cammonagu *)
lemma ejercicio_58_1:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule ccontr)
assume "¬ ((p ⟶ q) ∨ (q ⟶ p))"
hence 1: "¬(p ⟶ q) ∧ ¬(q ⟶ p)" by (rule ejercicio_46_1)

have "p ∨ ¬p" by (rule ejercicio_52_1)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
moreover {
assume "¬p"
hence "p ⟶ q" by (rule ejercicio_40_1)

have "¬(p ⟶ q)" using 1 by (rule conjunct1)
hence "False" using `p ⟶ q` by (rule notE)
}
ultimately show "False" by (rule disjE)
moreover {
assume "p"
hence "q ⟶ p" by (rule ejercicio_7_1)

have "¬(q ⟶ p)" using 1 by (rule conjunct2)
hence "False" using `q ⟶ p` by (rule notE)
}
qed

(* alfmarcua *)
lemma ejercicio_58_3:
"(p ⟶ q) ∨ (q ⟶ p)"
proof (rule disjE)
show "p ∨ ¬ p" by (rule ejercicio_52)
next
assume "¬p"
then have "p ⟶ q" by (rule ejercicio_40)
then show ?thesis by (rule disjI1)
next
assume "p"
then have "q ⟶ p" by (rule ejercicio_7)
then show ?thesis by (rule disjI2)
qed

end
</source>

Relación 5

2019-02-28T13:04:42Z

Jalonso:

Relación 4

2019-02-28T13:04:24Z

Jalonso:

Relación 3

2019-02-28T13:04:09Z

Jalonso:

Relación 2

2019-02-28T13:03:53Z

Jalonso:

Relación 1

2019-02-28T13:03:37Z

Jalonso:

Relación 6

2019-02-28T12:57:41Z

Jalonso:

Relación 5

2019-02-28T12:40:58Z

Jalonso:

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

theory R5_Recorridos_de_arboles_alu
imports Main
begin

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

datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"

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

text {*
---------------------------------------------------------------------
Ejercicio 2. Definir la función
preOrden :: "'a arbol ⇒ 'a list"
tal que (preOrden a) es el recorrido pre orden del árbol a. Por
ejemplo,
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden (H x) = [x]" |
"preOrden (N x i d) = x # preOrden i @ preOrden d"

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

text {*
---------------------------------------------------------------------
Ejercicio 3. Definir la función
postOrden :: "'a arbol ⇒ 'a list"
tal que (postOrden a) es el recorrido post orden del árbol a. Por
ejemplo,
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [e,c,a,d,g,f,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden (H x) = [x]" |
"postOrden (N x i d) = postOrden i @ postOrden d @ [x]"

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

text {*
---------------------------------------------------------------------
Ejercicio 4. Definir la función
inOrden :: "'a arbol ⇒ 'a list"
tal que (inOrden a) es el recorrido in orden del árbol a. Por
ejemplo,
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))
= [a,c,d,e,f,g,h]
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
gleherlop cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1
pabbergue alikan juacanrod antramhur *)
fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden (H x) = [x]" |
"inOrden (N x i d) = inOrden i @ [x] @ inOrden d"

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

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

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
gleherlop cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1
pabbergue alikan juacanrod antramhur *)
fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo (H x) = H x" |
"espejo (N x i d) = N x (espejo d) (espejo i)"

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

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

(* pabalagon manperjim raffergon2 josgomrom4 hugrubsan cammonagu
alfmarcua gleherlop enrparalv marfruman1 chrgencar pabbergue giafus1
alikan juacanrod aribatval antramhur *)
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 "... = rev (postOrden d @ [x]) @ rev (postOrden i)" by simp
also have "... = rev (postOrden i @ postOrden d @ [x])" by simp
finally show "?P (N x i d)" by simp
qed

(* benber *)
lemma "preOrden (espejo a) = rev (postOrden a)"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have "preOrden (espejo (N v l r)) =
preOrden (N v (espejo r) (espejo l))" by simp
also have "... = v # (preOrden (espejo r)) @ (preOrden (espejo l))"
by simp
also have "... = v # rev (postOrden r) @ rev (postOrden l)"
using IS.IH by simp
also have "... = rev ((postOrden l) @ (postOrden r) @ [v])" by simp
also have "... = rev (postOrden (N v l r))" by simp
finally show ?case .
qed

(* cammonagu *)
lemma "preOrden (espejo a) = rev (postOrden a)"
by (induction a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan aribatval *)
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" and 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 i @ preOrden d) @ rev [x]" by simp
also have "... = rev (x # preOrden i @ preOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* raffergon2 alfmarcua marfruman1 juacanrod antramhur *)
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
finally show "?P (N x i d)" by simp
qed

(* benber cammonagu *)
lemma "postOrden (espejo a) = rev (preOrden a)"
by (induction a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan juacanrod aribatval *)
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 H1: "?P i" and 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
also have "... = rev (inOrden i @ [x] @ inOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* raffergon2 alfmarcua marfruman1 antramhur *)
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 H1: "?P i"
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
also have "... = rev(x # inOrden d) @ rev (inOrden i)" by simp
also have "... = rev(inOrden i @ x # inOrden d)" by simp
finally show "?P (N x i d)" by simp
qed

(* benber *)
theorem "inOrden (espejo a) = rev (inOrden a)"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have "inOrden (espejo (N v l r)) =
inOrden (N v (espejo r) (espejo l))" by simp
also have "... = (inOrden (espejo r)) @ [v] @ (inOrden (espejo l))"
by simp
also have "... = (rev (inOrden r)) @ [v] @ (rev (inOrden l))"
using IS.IH by simp
also have "... = rev ((inOrden l) @ [v] @ (inOrden r))" by simp
also have"... = rev (inOrden (N v l r))" by simp
finally show ?case .
qed

(* cammonagu*)
lemma "inOrden (espejo a) = rev (inOrden a)"
by (induction a) auto

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

(* pabalagon manperjim raffergon2 aribatval benber josgomrom4 hugrubsan
cammonagu antramhur alfmarcua enrparalv marfruman1 gleherlop
chrgencar giafus1 pabbergue alikan juacanrod *)
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
---------------------------------------------------------------------
*}

(* pabalagon manperjim raffergon2 benber josgomrom4 gleherlop hugrubsan
cammonagu alfmarcua enrparalv marfruman1 chrgencar giafus1 pabbergue
alikan juacanrod aribatval antramhur *)
fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda (H x) = x" |
"extremo_izquierda (N x i d) = extremo_izquierda i"

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

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

(* pabalagon manperjim raffergon2 benber josgomrom4 hugrubsan cammonagu
alfmarcua gleherlop enrparalv marfruman1 chrgencar giafus1 pabbergue
alikan juacanrod antramhur *)
fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha (H x) = x" |
"extremo_derecha (N x i d) = extremo_derecha d"

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

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
enrparalv gleherlop chrgencar marfruman1 giafus1 pabbergue alikan
juacanrod antramhur *)
lemma inOrdenNotNil: "inOrden a ≠ []" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x i d
have "?P (N x i d) = ((inOrden i @ [x] @ inOrden d) ≠ [])" by simp
also have "... = ((inOrden i ≠ []) ∨ ([x] ≠ []) ∨ (inOrden d ≠ []))"
by simp
also have "... = ([x] ≠ [])" by simp
finally show "?P (N x i d)" by simp
qed

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 HI: "?P d"
have "last (inOrden (N x i d)) = last (inOrden i @ [x] @ inOrden d)"
by simp
also have "... = last (x # inOrden d)" by simp
also have "... = last (inOrden d)" by (simp add: inOrdenNotNil)
also have "... = extremo_derecha d" using HI by simp
also have "... = extremo_derecha (N x i d)" by simp
finally show "?P (N x i d)" .
qed

(* benber *)
theorem "last (inOrden a) = extremo_derecha a"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
have 1: "last (xs@ys) = last ys" if "ys ≠ []" for xs ys :: "'a list"
proof (induction xs)
case Nil
show ?case by simp
next
case IS: (Cons x xs)
have "last ((x#xs)@ys) = last (x#(xs@ys))" by simp
also have "... = last (xs @ ys)" using `ys ≠ []` by simp
also have "... = last ys" using IS.IH by simp
finally show ?case .
qed
have 2: "inOrden a ≠ []" for a :: "'a arbol"
by (induction a) auto
have "last (inOrden (N v l r)) =
last ( (inOrden l) @ [v] @ (inOrden r) )" by simp
also have "... = last (inOrden r)" using 1 2 by auto
also have "... = extremo_derecha r" using IS.IH by simp
also have "... = extremo_derecha (N v l r)" by simp
finally show ?case .
qed

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop enrparalv marfruman1 chrgencar giafus1 pabbergue alikan
juacanrod aribatval antramhur *)
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")
proof (induct a)
fix x::'a
have "hd (inOrden (H x)) = hd [x]" by simp
also have "... = x" by simp
also have "... = extremo_izquierda (H x)" by simp
finally show "?P (H x)" .
next
fix x i d
assume HI: "?P i"
have "hd (inOrden (N x i d)) = hd (inOrden i @ [x] @ inOrden d)"
by simp
also have "... = hd ((inOrden i @ [x]) @ inOrden d)" by simp
also have "... = hd (inOrden i)" by (simp add: inOrdenNotNil)
also have "... = extremo_izquierda i" using HI by simp
also have "... = extremo_izquierda (N x i d)" by simp
finally show "?P (N x i d)" .
qed

(* benber *)
theorem "hd (inOrden a) = extremo_izquierda a"
proof (induction a)
case (H v)
show ?case by simp
next
case IS: (N v l r)
moreover have "inOrden a ≠ []" for a :: "'a arbol"
by (induction a) auto
ultimately show ?case by simp
qed

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop marfruman1 chrgencar giafus1 pabbergue alikan juacanrod
aribatval antramhur *)
theorem hdPreOrden_lastPostOrden:
"hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "hd (preOrden (N x i d)) = hd (x # preOrden i @ preOrden d)"
by simp
also have "... = x" by simp
also have "... = last [x]" by simp
also have "... = last (postOrden i @ postOrden d @ [x])" by simp
finally show "?P (N x i d)" by simp
qed

(* enrparalv *)
theorem "hd (preOrden a) = last (postOrden a)" (is "?P a")
proof (induct a)
fix x::'a
have "hd (preOrden (H x)) = hd [x]" by simp
also have "... = x" by simp
also have "... = last [x]" by simp
also have "... = last (postOrden (H x))" by simp
finally show "?P (H x)" by simp
next
fix x i d
have "hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)"
by simp
also have "... = hd ([x] @ preOrden i)" by simp
also have "... = x" by simp
also have "... = last [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
oops

(* benber cammonagu *)
theorem "hd (preOrden a) = last (postOrden a)"
by (cases a) auto

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

(* pabalagon manperjim josgomrom4 hugrubsan cammonagu alfmarcua
gleherlop marfruman1 chrgencar giafus1 pabbergue alikan juacanrod
aribatval antramhur *)
theorem hdPreOrden_raiz: "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "hd (preOrden (N x i d)) = hd (x # preOrden i @ preOrden d)"
by simp
also have "... = x" by simp
finally show "?P (N x i d)" by (simp only: raiz.simps(2))
qed

(* enrparalv *)
theorem "hd (preOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x::'a
have "hd (preOrden (H x)) = hd [x]" by simp
also have "... = x " by simp
also have "... = raiz (H x)" by (simp only: raiz.simps(1))
finally show "?P (H x)" by simp
next
fix x i d
have "hd (preOrden (N x i d)) = hd ([x] @ preOrden i @ preOrden d)" by simp
also have "... = hd (([x] @ preOrden i) @ preOrden d)" by simp
also have "... = hd ([x] @ preOrden i)" by simp
also have "... = hd ([x])" by simp
also have "... = x" by simp
finally show "?P (N x i d)" by (simp only: raiz.simps(2))
oops

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

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

(* pabalagon manperjim cammonagu alfmarcua marfruman1 gleherlop
chrgencar giafus1 pabbergue juacanrod hugrubsan alikan aribatval
antramhur *)
theorem "hd (inOrden a) = raiz a"
quickcheck
(*
Quickcheck found a counterexample:
a = N a⇩1 (H a⇩2) (H a⇩1)
Evaluated terms:
hd (inOrden a) = a⇩2
raiz a = a⇩1 *)
oops

(* benber josgomrom4 *)
(* El teorema no es cierto para arboles sobre numeros naturales *)
theorem "¬(∀ a :: nat arbol. hd (inOrden a) = raiz a)"
proof -
let ?a = "(N 0 (H 1) (H 2)) :: nat arbol"
have "hd (inOrden ?a) = 1" by simp
moreover have "raiz ?a = 0" by simp
ultimately have "hd (inOrden ?a) ≠ raiz ?a" by simp
hence "∃ a :: nat arbol. hd (inOrden a) ≠ raiz a" by (simp only: exI)
thus ?thesis by auto
qed

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

(* pabalagon manperjim josgomrom4 cammonagu marfruman1 gleherlop
chrgencar giafus1 pabbergue juacanrod hugrubsan aribatval antramhur *)
theorem "last (postOrden a) = raiz a"
proof -
have "last (postOrden a) = hd (preOrden a)"
by (simp add: hdPreOrden_lastPostOrden)
also have "... = raiz a" by (simp add: hdPreOrden_raiz)
finally show "?thesis" .
qed

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

(* alfmarcua *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x
show "?P (H x)" by simp
next
fix x::'a
fix i d
have "last (postOrden (N x i d)) =
last (postOrden i @ postOrden d @ [x])" by simp
also have "... = x" by simp
finally show "?P (N x i d)" by simp
qed

(* enrparalv *)
theorem "last (postOrden a) = raiz a" (is "?P a")
proof (induct a)
fix x::'a
have "last (postOrden (H x)) = last [x]" by simp
also have "... = x" by simp
also have "... = raiz (H x)" by (simp only: raiz.simps(1))
finally show "?P (H x)" by simp
next
fix x i 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 only: raiz.simps(2))
finally show "?P (N x i d)" by simp
oops

end
</source>

Relación 4

2019-02-28T11:04:31Z

Jalonso:

<source lang="isabelle">
chapter {* R4: Cuantificadores sobre listas *}

theory R4_Cuantificadores_sobre_listas_alu
imports Main
begin

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

Nota: La función todos es equivalente a la predefinida list_all.
---------------------------------------------------------------------
*}

(* manperjim pabalagon alfmarcua josgomrom4 aribatval cammonagu
raffergon2 enrparalv gleherlop chrgencar benber giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True" |
"todos p (x#xs) = (p x ∧ todos p xs)"

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

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

(* manperjim pabalagon alfmarcua josgomrom4 cammonagu aribatval
raffergon2 enrparalv gleherlop chrgencar benber giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan *)
fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"algunos p [] = False" |
"algunos p (x#xs) = (p x ∨ algunos p xs)"

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

(* manperjim pabalagon alfmarcua josgomrom4 cammonagu raffergon2
enrparalv gleherlop chrgencar benber giafus1 pabbergue alikan
marfruman1 antramhur juacanrod hugrubsan aribatval *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
by (induct xs) auto

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

(* pabalagon *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P P Q xs")
proof (induct xs)
fix P Q
show "?P P Q []" by simp
next
fix a xs
assume HI: "?P P Q xs"
have "todos (λx. P x ∧ Q x) (a#xs) =
((P a ∧ Q a) ∧ todos (λx. P x ∧ Q x) xs)" by simp
also have "... = (P a ∧ Q a ∧ todos P xs ∧ todos Q xs)"
using HI by simp
also have "... = ((P a ∧ todos P xs) ∧ (Q a ∧ todos Q xs))"
by (simp add: HOL.conj_comms)
also have "... = (todos P (a#xs) ∧ (Q a ∧ todos Q xs))" by simp
finally show "todos (λx. P x ∧ Q x) (a#xs) =
(todos P (a#xs) ∧ todos Q (a#xs))" by simp
qed

(* alfmarcua juacanrod *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)" (is "?P xs")
proof (induct xs)
have "todos (λx. P x ∧ Q x) [] = (True)"
by (simp only: todos.simps(1))
also have "... = (True ∧ True)" by (simp only: conj_absorb)
also have "... = (todos P [] ∧ todos Q [])"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix x xs
assume HI: "?P xs"
have "todos (λx. P x ∧ Q x) (x # xs) =
((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)"
by (simp only: todos.simps(2))
also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))"
by (simp only: HI)
also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))"
by (simp only: HOL.conj_comms)
also have "... = (todos P (x # xs) ∧ todos Q (x # xs))"
by (simp only: todos.simps(2))
finally show "?P (x#xs)" .
qed

(* manperjim josgomrom4 raffergon2 cammonagu enrparalv gleherlop
chrgencar giafus1 pabbergue alikan marfruman1 antramhur hugrubsan
aribatval *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp
next
fix n xs
assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
have "todos (λx. P x ∧ Q x) (n # xs) =
((P n ∧ Q n) ∧ (todos P xs ∧ todos Q xs))" using HI by simp
also have "... = ((P n ∧ todos P xs) ∧ (Q n ∧ todos Q xs))" by arith
also have "... = ((todos P(n#xs)) ∧ (todos Q(n#xs)))" by simp
finally show "todos (λx. P x ∧ Q x) (n#xs) =
(todos P (n#xs) ∧ todos Q (n#xs))" by simp
qed

(* benber *)
lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"
proof (induct xs)
case Nil
have "todos (λx. P x ∧ Q x) [] = True" by (simp only: todos.simps(1))
also have "... = (todos P [] ∧ todos Q [])"
by (simp only: todos.simps(1) conj_absorb)
finally show ?case.
next
case (Cons x xs)
assume IH: "todos (λy. P y ∧ Q y) xs = (todos P xs ∧ todos Q xs)"
have "todos (λy. P y ∧ Q y) (x # xs) =
( (P x ∧ Q x) ∧ todos (λy. P y ∧ Q y) xs )"
by (simp only: todos.simps(2))
also have "... = ( (P x ∧ Q x) ∧ todos P xs ∧ todos Q xs )"
by (simp only: IH)
also have "... = ( P x ∧ (Q x ∧ todos P xs) ∧ todos Q xs )"
by (simp only: conj_assoc)
also have "... = ( P x ∧ (todos P xs ∧ Q x) ∧ todos Q xs )"
by (simp only: conj_commute)
also have "... = ( (P x ∧ todos P xs) ∧ Q x ∧ todos Q xs )"
by (simp only: conj_assoc)
also have "... = ( todos P (x#xs) ∧ todos Q (x#xs) )"
by (simp only: todos.simps(2))
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 4.1. Demostrar o refutar automáticamente
todos P (x @ y) = (todos P x ∧ todos P y)
---------------------------------------------------------------------
*}

(* manperjim pabalagon alfmarcua josgomrom4 aritbatval cammonagu
raffergon2 enrparalv benber gleherlop chrgencar giafus1 pabbergue
alikan marfruman1 antramhur juacanrod hugrubsan aribatval *)
lemma "todos P (x @ y) = (todos P x ∧ todos P y)"
by (induct x) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 cammonagu enrparalv
gleherlop chrgencar giafus1 pabbergue alikan antramhur juacanrod
hugrubsan *)
lemma todos_append:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x)
show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp
next
fix a x
assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a#x) @ y) = (P a ∧ todos P (x @ y))" by simp
also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp
finally show "todos P ((a#x) @ y) = (todos P (a#x) ∧ todos P y)"
by simp
qed

(* alfmarcua marfruman1 *)
lemma todos_append_2:
"todos P (x @ y) = (todos P x ∧ todos P y)" (is "?P x")
proof (induct x)
have "todos P ([] @ y) = todos P y" by (simp only: append_Nil)
also have "... = (True ∧ todos P y)" by (simp only: simp_thms(22))
also have "... = (todos P [] ∧ todos P y)"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix a x
assume HI:"?P x"
have "todos P ((a # x) @ y) = todos P (a # (x @ y))"
by (simp only:List.append.append_Cons)
also have "... = (P a ∧ todos P (x @ y))"
by (simp only: todos.simps(2))
also have "... = (P a ∧ todos P x ∧ todos P y)" by (simp only:HI)
also have "... = ((P a ∧ todos P x) ∧ todos P y)"
by (simp only:HOL.conj_assoc)
also have "... = (todos P (a#x) ∧ todos P y)"
by (simp only: todos.simps(2))
finally show "?P (a#x)" .
qed

(* benber *)
lemma todos_append_3:
"todos P (x @ y) = (todos P x ∧ todos P y)"
proof (induct x )
case Nil
have "todos P ( [] @ y ) = todos P y"
by (simp only: List.append.left_neutral)
also have "... = (todos P [] ∧ todos P y)"
by (simp only: todos.simps(1) simp_thms(22))
finally show ?case.
next
case (Cons a x)
assume IH: "todos P (x @ y) = (todos P x ∧ todos P y)"
have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))"
by (simp only: todos.simps(2) List.append.append_Cons)
also have "... = (P a ∧ todos P x ∧ todos P y)" by (simp only: IH)
also have "... = (todos P (a#x) ∧ todos P y)"
by (simp only: todos.simps(2) conj_assoc )
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 5.1. Demostrar o refutar automáticamente
todos P (rev xs) = todos P xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua aribatval cammonagu
raffergon2 giafus1 pabbergue enrparalv alikan antramhur juacanrod
hugrubsan *)
lemma "todos P (rev xs) = todos P xs"
by (induct xs) (simp_all add: HOL.conj_comms todos_append)

(* benber marfruman1*)
lemma "todos P (rev xs) = todos P xs"
using todos_append by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 cammonagu gleherlop giafus1
pabbergue enrparalv marfruman1 alikan chrgencar antramhur juacanrod
hugrubsan aribatval *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
show "todos P (rev []) = todos P []" by simp
next
fix a xs
assume HI: "todos P (rev xs) = todos P xs"
have "todos P (rev (a#xs)) = todos P ((rev xs) @ [a])" by simp
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp add: todos_append)
also have "... = (todos P xs ∧ todos P [a])" using HI by simp
also have "... = (todos P xs ∧ P a)" by simp
also have "... = (P a ∧ todos P xs)" by (simp add: HOL.conj_comms)
finally show "todos P (rev (a#xs)) = todos P (a#xs)" by simp
qed

(* alfmarcua *)
lemma "todos P (rev xs) = todos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: rev.simps(1))
next
fix a xs
assume HI:"?P xs"
have "todos P (rev (a # xs)) = todos P (rev xs @ [a])"
by (simp only: rev.simps(2))
also have "... = (todos P (rev xs) ∧ todos P [a])"
by (simp only: todos_append)
also have "... = (todos P xs ∧ todos P [a])" by (simp only: HI)
also have "... = (todos P (a#[]) ∧ todos P xs)"
by (simp only: HOL.conj_comms)
also have "... = ((P a ∧ True) ∧ todos P xs)"
by (simp only: todos.simps)
also have "... = (P a ∧ todos P xs)"
by (simp only: HOL.simp_thms(21))
also have "... = todos P (a#xs)" by (simp only: todos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "todos P (rev xs) = todos P xs"
proof (induct xs)
case Nil
show "todos P (rev []) = todos P []" by (simp only: rev.simps(1))
next
case (Cons x xs)
assume IH: "todos P (rev xs) = todos P xs"
have "todos P (rev (x#xs)) = todos P (rev xs @ [x])"
by (simp only: rev.simps(2))
also have "... = (todos P (rev xs) ∧ todos P [x] )"
by (simp only: todos_append)
also have "... = (todos P (rev xs) ∧ P x ∧ todos P [])"
by (simp only: todos.simps(2))
also have "... = (todos P (rev xs) ∧ P x)"
by (simp only: todos.simps(1) simp_thms(21))
also have "... = (todos P xs ∧ P x)" by (simp only: IH)
also have "... = (todos P (x#xs))"
by (simp only: todos.simps(2) conj_commute)
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar o refutar:
algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)
---------------------------------------------------------------------
*}

(* pabalagon *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
nitpick
oops

(* Contraejemplo *)
value "algunos (λx. even x ∧ odd x) [1, 2::nat] ≠
algunos even [1, 2::nat] ∧ algunos odd [1, 2::nat]"

(* manperjim alfmarcua raffergon2 gleherlop chrgencar cammonagu giafus1
pabbergue marfruman1 alikan antramhur juacanrod hugrubsan
aribatval *)
lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"
quickcheck
oops

(* benber (demostración no completa) *)
fun is_zero :: "nat ⇒ bool" where
"is_zero n = (n = 0)"
fun is_one :: "nat ⇒ bool" where
"is_one n = (n = 1)"
lemma "¬( ∀P Q xs. algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs) )"
proof -
let ?P = is_one
let ?Q = is_zero
have "algunos (λx. ?P x ∧ ?Q x) [0,1] ≠
(algunos ?P [0,1] ∧ algunos ?Q [0,1])" by simp
hence "∃ xs. algunos (λx. ?P x ∧ ?Q x) xs ≠
(algunos ?P xs ∧ algunos ?Q xs)" by (simp only: exI)
hence "∃Q xs. algunos (λx. ?P x ∧ Q x) xs ≠
(algunos ?P xs ∧ algunos Q xs)"
by (simp only: exI[of "λQ. ∃ xs. algunos (λx. ?P x ∧ Q x) xs ≠ (algunos ?P xs ∧ algunos Q xs)"])
hence "∃P Q xs. algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)"
(*
No sé por qué esto no funciona:
by (simp only: exI[of "λP Q xs. algunos (λx. P x ∧ Q x) xs ≠ (algunos P xs ∧ algunos Q xs)" ?P])

Parece que el problema es la expresión lambda.
*)
sorry
thus ?thesis by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 7.1. Demostrar o refutar automáticamente
algunos P (map f xs) = algunos (P ∘ f) xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 gleherlop
cammonagu benber giafus1 pabbergue enrparalv marfruman1 alikan
antramhur juacanrod hugrubsan aribatval *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
by (induct xs) auto

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

(* manperjim pabalagon cammonagu giafus1 gleherlop chrgencar pabbergue
enrparalv marfruman1 alikan antramhur juacanrod hugrubsan *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P ∘ f) []" by simp
next
fix a xs
assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (a#xs)) = (P (f a) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f a) ∨ algunos (P ∘ f) xs)" using HI by simp
also have "... = ((P ∘ f) a ∨ algunos (P ∘ f) xs)" by simp
finally show "algunos P (map f (a#xs)) = algunos (P ∘ f) (a#xs)"
by simp
qed

(* josgomrom4 *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
show "algunos P (map f []) = algunos (P o f) []" by simp
next
fix x xs
assume HI: "algunos P (map f xs) = algunos (P o f) xs"
have "algunos P (map f (x#xs)) = (P (f x) ∨ algunos P (map f xs))"
by simp
also have "... = (P (f x) ∨ algunos (P o f) xs)" using HI by simp
finally show "algunos P (map f (x#xs)) = algunos (P o f) (x#xs)"
by simp
qed

(* alfmarcua *)
lemma "algunos P (map f xs) = algunos (P o f) xs" (is "?P xs")
proof (induct xs)
have "algunos P (map f []) = algunos P []"
by (simp only: List.list.map(1))
also have "... = algunos (P o f) []" by (simp only: algunos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P (map f (a # xs)) = algunos P (f a # map f xs)"
by (simp only: List.list.map(2))
also have "... = (P (f a) ∨ algunos P (map f xs))"
by (simp only: algunos.simps(2))
also have "... = (P (f a) ∨ algunos (P o f) xs)" by (simp only:HI)
also have "... = ((P o f) a ∨ algunos (P o f) xs)"
by (simp only: Fun.comp_apply)
also have "... = algunos (P o f) (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P (map f xs) = algunos (P o f) xs"
proof (induct xs)
case Nil
have "algunos P (map f []) = algunos P []" by (simp only: list.map(1))
also have "... = False" by (simp only: algunos.simps(1))
also have "False = algunos (P ∘ f) []" by (simp only: algunos.simps(1))
finally show ?case.
next
case (Cons x xs)
assume IH: "algunos P (map f xs) = algunos (P ∘ f) xs"
have "algunos P (map f (x # xs)) = algunos P (f x # map f xs)"
by (simp only: list.map(2))
also have "... = ( (P ∘ f) x ∨ algunos P (map f xs) )"
by (simp only: algunos.simps(2) o_apply)
also have "... = ( (P ∘ f) x ∨ algunos (P ∘ f) xs )"
by (simp only: IH)
also have "... = algunos (P ∘ f) (x#xs)"
by (simp only: algunos.simps(2))
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 8.1. Demostrar o refutar automáticamente
algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
alikan antramhur juacanrod hugrubsan aribatval *)
lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 raffergon2 gleherlop cammonagu giafus1
pabbergue enrparalv marfruman1 alikan antramhur juacanrod hugrubsan *)
lemma algunos_append:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp
next
fix a xs
assume HI: "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
have "algunos P ((a#xs) @ ys) = (P a ∨ algunos P (xs @ ys))" by simp
also have "... = (P a ∨ algunos P xs ∨ algunos P ys)" using HI by simp
finally show "algunos P ((a#xs) @ ys) =
(algunos P (a#xs) ∨ algunos P ys)" by simp
qed

(* alfmarcua *)
lemma algunos_append_2:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)" (is "?P xs")
proof (induct xs)
have "algunos P ([] @ ys) = algunos P ys" by (simp only: append_Nil)
also have "... = (False ∨ algunos P ys)" by (simp only: simp_thms(32))
also have "... = (algunos P [] ∨ algunos P ys)"
by (simp only: algunos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P ((a # xs) @ ys) = algunos P (a # (xs @ ys))"
by (simp only:List.append.append_Cons)
also have "... = (P a ∨ algunos P (xs @ ys))"
by (simp only: algunos.simps(2))
also have "... = (P a ∨ algunos P xs ∨ algunos P ys)"
by (simp only:HI)
also have "... = ((P a ∨ algunos P xs) ∨ algunos P ys)"
by (simp only:HOL.disj_assoc)
also have "... = (algunos P (a#xs) ∨ algunos P ys)"
by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma algunos_append_3:
"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"
proof (induct xs)
case Nil
have "algunos P ([] @ ys) = algunos P ys"
by (simp only: append.left_neutral)
also have "... = ( algunos P [] ∨ algunos P ys )"
by (simp only: algunos.simps(1) simp_thms(32))
finally show ?case .
next
case (Cons x xs)
assume IH: "algunos P (xs @ ys) = ( algunos P xs ∨ algunos P ys )"
have "algunos P ((x#xs) @ ys) = algunos P (x#(xs @ ys))"
by (simp only: append_Cons)
also have "... = ( P x ∨ algunos P (xs @ ys) )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ algunos P xs ∨ algunos P ys )"
by (simp only: IH)
also have "... = ( algunos P (x#xs) ∨ algunos P ys )"
by (simp only: algunos.simps(2) disj_assoc)
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 9.1. Demostrar o refutar automáticamente
algunos P (rev xs) = algunos P xs
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 gleherlop chrgencar
cammonagu giafus1 pabbergue enrparalv alikan antramhur juacanrod
hugrubsan aribatval *)
lemma "algunos P (rev xs) = algunos P xs"
by (induct xs) (simp_all add: HOL.disj_comms algunos_append)

(* benber marfruman1 *)
lemma "algunos P (rev xs) = algunos P xs"
using algunos_append by (induct xs) auto

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

(* pabalagon juacanrod *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a#xs)) = algunos P (rev xs @ [a])" by simp
also have "... = (algunos P (rev xs) ∨ algunos P [a])"
by (simp add: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" using HI by simp
also have "... = (algunos P xs ∨ P a)" by simp
also have "... = (P a ∨ algunos P xs)" by (simp add: HOL.disj_comms)
finally show "algunos P (rev (a#xs)) = algunos P (a#xs)" by simp
qed

(* manperjim josgomrom4 raffergon2 gleherlop chrgencar cammonagu giafus1
pabbergue enrparalv marfruman1 alikan antramhur hugrubsan *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
show "algunos P (rev []) = algunos P []" by simp
next
fix a xs
assume HI:"algunos P (rev xs) = algunos P xs"
have "algunos P (rev (a # xs)) = algunos P ((rev xs) @ [a])" by simp
also have "... = ((algunos P (rev xs)) ∨ (algunos P [a]))"
by (simp add: algunos_append)
also have "... = ((algunos P xs) ∨ (algunos P [a]))" using HI by simp
also have "... = ((algunos P [a]) ∨ (algunos P xs))" by arith
finally show "algunos P (rev (a # xs)) = algunos P (a # xs)" by simp
qed

(* alfmarcua *)
lemma "algunos P (rev xs) = algunos P xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: rev.simps(1))
next
fix a xs
assume HI:"?P xs"
have "algunos P (rev (a # xs)) = algunos P (rev xs @ [a])"
by (simp only: rev.simps(2))
also have "... = (algunos P (rev xs) ∨ algunos P [a])"
by (simp only: algunos_append)
also have "... = (algunos P xs ∨ algunos P [a])" by (simp only: HI)
also have "... = (algunos P (a#[]) ∨ algunos P xs)"
by (simp only: HOL.disj_comms)
also have "... = ((P a ∨ False) ∨ algunos P xs)"
by (simp only: algunos.simps)
also have "... = (P a ∨ algunos P xs)"
by (simp only: HOL.simp_thms(31))
also have "... = algunos P (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P (rev xs) = algunos P xs"
proof (induct xs)
case Nil
show ?case by (simp only: algunos.simps(1) rev.simps(1))
next
case (Cons x xs)
assume IH: "algunos P (rev xs) = algunos P xs"
have "algunos P (rev (x#xs)) = algunos P ( (rev xs) @ [x] )"
by (simp only: rev.simps(2))
also have "... = ( algunos P (rev xs) ∨ algunos P [x] )"
by (simp only: algunos_append)
also have "... = ( algunos P (rev xs) ∨ P x ∨ algunos P [] )"
by (simp only: algunos.simps(2))
also have "... = ( algunos P (rev xs) ∨ P x )"
by (simp only: algunos.simps(1) simp_thms(31))
also have "... = (algunos P xs ∨ P x)" by (simp only: IH)
also have "... = algunos P (x#xs)"
by (simp only: algunos.simps(2) disj_commute)
finally show ?case.
qed

text {*
---------------------------------------------------------------------
Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la
siguiente ecuación:
algunos (λx. P x ∨ Q x) xs = Z
y demostrar la equivalencia de forma automática y detallada.
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 enrparalv marfruman1 antramhur
alikan hugrubsan aribatval *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
by (induct xs) auto

(* pabalagon josgomrom4 cammonagu pabbergue marfruman1 antramhur
juacanrod alikan *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
proof (induct xs)
show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])"
by simp
next
fix a xs
assume HI: "algunos (λx. P x ∨ Q x) xs =
(algunos P xs ∨ algunos Q xs)"
have "algunos (λx. P x ∨ Q x) (a#xs) =
(P a ∨ Q a ∨ algunos (λx. P x ∨ Q x) xs)" by simp
also have "... = (P a ∨ Q a ∨ algunos P xs ∨ algunos Q xs)"
using HI by simp
also have "... = (P a ∨ algunos P xs ∨ Q a ∨ algunos Q xs)"
by (simp add: HOL.disj_comms)
finally show "algunos (λx. P x ∨ Q x) (a#xs) =
(algunos P (a#xs) ∨ algunos Q (a#xs))" by simp
qed

(* alfmarcua *)
lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"
(is "?P xs")
proof (induct xs)
show "?P []" by (simp only: algunos.simps(1) HOL.simp_thms(33))
next
fix a xs
assume HI:"?P xs"
have "algunos (λx. P x ∨ Q x) (a # xs) =
((P a ∨ Q a) ∨ algunos (λx. P x ∨ Q x) xs)"
by (simp only: algunos.simps(2))
also have "... = ((P a ∨ Q a) ∨ algunos P xs ∨ algunos Q xs)"
by (simp only: HI)
also have "... = ((P a ∨ algunos P xs) ∨ Q a ∨ algunos Q xs)"
by (simp only: HOL.disj_assoc HOL.disj_comms)
also have "... = (algunos P (a # xs) ∨ algunos Q (a # xs))"
by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos (λx. P x ∨ Q x) xs = ( algunos P xs ∨ algunos Q xs )"
proof (induct xs)
case Nil
have "algunos (λx. P x ∨ Q x) [] = False"
by (simp only: algunos.simps(1))
also have "... = ( algunos P [] ∨ algunos Q [] )"
by (simp only: algunos.simps(1) simp_thms(31))
finally show ?case.
next
case (Cons x xs)
let ?R = "λx. P x ∨ Q x"
assume IH: "algunos ?R xs = ( algunos P xs ∨ algunos Q xs )"
have "algunos ?R (x#xs) = ( ?R x ∨ algunos ?R xs )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ Q x ∨ algunos P xs ∨ algunos Q xs )"
by (simp only: IH disj_assoc)
also have "... = ( P x ∨ (Q x ∨ algunos P xs) ∨ algunos Q xs )"
by (simp only: disj_assoc)
also have "... = ( P x ∨ (algunos P xs ∨ Q x) ∨ algunos Q xs )"
by (simp only: disj_commute)
also have "... = ( algunos P (x#xs) ∨ algunos Q (x#xs) )"
by (simp only: algunos.simps(2) disj_assoc)
finally show ?case .
qed

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

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
antramhur juacanrod alikan hugrubsan aribatval *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
by (induct xs) auto

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

(* manperjim pabalagon josgomrom4 cammonagu pabbergue enrparalv
marfruman1 antramhur juacanrod alikan hugrubsan aribatval *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
have "algunos P [] = False" by simp
also have "... = (¬ todos (λx. (¬ P x)) [])" by simp
finally show "algunos P [] = (¬ todos (λx. (¬ P x)) [])" by simp
next
fix a xs
assume HI: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "(¬ todos (λx. (¬ P x)) (a#xs)) =
(¬ ((¬ P a) ∧ todos (λx. (¬ P x)) xs))" by simp
also have "... = (P a ∨ ¬ todos (λx. (¬ P x)) xs)" by simp
also have "... = (P a ∨ algunos P xs)" using HI by simp
finally show "algunos P (a#xs) = (¬ todos (λx. (¬ P x)) (a#xs))"
by simp
qed

(* alfmarcua *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)" (is "?P xs")
proof (induct xs)
have "algunos P [] = False" by (simp only:algunos.simps(1))
also have "... = (¬ True)" by (simp only: HOL.simp_thms(7))
also have "... = (¬ todos (λx. (¬ P x)) [])"
by (simp only: todos.simps(1))
finally show "?P []" .
next
fix a xs
assume HI:"?P xs"
have "algunos P (a # xs) = (P a ∨ algunos P xs)"
by (simp only: algunos.simps(2))
also have "... = (P a ∨ ¬ todos (λx. (¬ P x)) xs)"
by (simp only: HI)
also have "... = (¬ ¬ P a ∨ ¬ todos (λx. (¬ P x)) xs)"
by (simp only: HOL.simp_thms(1))
also have "... = (¬ (¬ P a ∧ todos (λx. (¬ P x)) xs))"
by (simp only: HOL.de_Morgan_conj)
also have "... = (¬ todos (λx. (¬ P x)) (a#xs))"
by (simp only: todos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
proof (induct xs)
case Nil
have "algunos P [] = False" by (simp only: algunos.simps(1))
also have "False = (¬ todos (λx. ¬ P x) [])"
by (simp only: todos.simps(1) not_True_eq_False)
finally show ?case .
next
case (Cons x xs)
assume IH: "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"
have "algunos P (x#xs) = ( P x ∨ algunos P xs )"
by (simp only: algunos.simps(2))
also have "... = ( P x ∨ (¬ todos (λx. (¬ P x)) xs) )"
by (simp only: IH)
also have "... = ( ¬( ¬ P x ∧ todos (λx. (¬ P x)) xs) )"
by (simp only: not_not de_Morgan_conj)
also have "... = (¬ todos (λx. (¬ P x)) (x#xs))"
by (simp only: todos.simps(2))
finally show ?case .
qed

text {*
---------------------------------------------------------------------
Ejercicio 12. Definir la funcion primitiva recursiva
estaEn :: 'a ⇒ 'a list ⇒ bool
tal que (estaEn x xs) se verifica si el elemento x está en la lista
xs. Por ejemplo,
estaEn (2::nat) [3,2,4] = True
estaEn (1::nat) [3,2,4] = False
---------------------------------------------------------------------
*}

(* manperjim pabalagon josgomrom4 alfmarcua raffergon2 cammonagu
gleherlop chrgencar benber giafus1 pabbergue enrparalv marfruman1
antramhur juacanrod alikan hugrubsan aribatval *)
fun estaEn :: "'a ⇒ 'a list ⇒ bool" where
"estaEn x [] = False" |
"estaEn x (y#xs) = (x=y ∨ estaEn x xs)"

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

(* manperjim pabalagon josgomrom4 alfmarcua cammonagu gleherlop
chrgencar benber giafus1 pabbergue marfruman1 antramhur juacanrod
alikan *)
lemma "estaEn x xs = algunos (λa. x=a) xs"
by (induct xs) auto

(* pabalagon josgomrom4 cammonagu marfruman1 antramhur *)
lemma "estaEn x xs = algunos (λa. x=a) xs"
proof (induct xs)
show "estaEn x [] = algunos (λa. x=a) []" by simp
next
fix y xs
assume HI: "estaEn x xs = algunos (λa. x=a) xs"
have "estaEn x (y#xs) = (x=y ∨ estaEn x xs)" by simp
also have "... = (x=y ∨ algunos (λa. x=a) xs)" using HI by simp
finally show "estaEn x (y#xs) = algunos (λa. x=a) (y#xs)" by simp
qed

(* alfmarcua *)
lemma "estaEn x xs = algunos (λk. x=k) xs" (is "?P xs")
proof (induct xs)
show "?P []" by (simp only: estaEn.simps(1) algunos.simps(1))
next
fix a xs
assume HI:"?P xs"
have "estaEn x (a # xs) = (x=a ∨ estaEn x xs)"
by (simp only: estaEn.simps(2))
also have "... = (x=a ∨ algunos (λk. x=k) xs)" by (simp only: HI)
(* also have "... = ((λk. x=k) a ∨ algunos (λk. x=k) xs)" by (simp only:HOL.simp_thms(6)) *)
also have "... = algunos (λk. x=k) (a#xs)" by (simp only: algunos.simps(2))
finally show "?P (a#xs)" .
qed

(* benber *)
lemma "estaEn x xs = (algunos (λy. y = x) xs)"
proof (induct xs)
case Nil
have "estaEn x [] = False" by (simp only: estaEn.simps(1))
also have "False = (algunos (λy. y = x) [])"
by (simp only: algunos.simps(1))
finally show ?case .
next
case (Cons z xs)
assume IH: "estaEn x xs = algunos (λy. y = x) xs"
have "estaEn x (z#xs) = ( z = x ∨ estaEn x xs )" by force
also have "... = ( z = x ∨ algunos (λy. y = x) xs)" by (simp only: IH)
also have "... = (algunos (λy. y = x) (z#xs))"
by (simp only: algunos.simps(2))
finally show ?case .
qed

end
</source>

Relación 3

2019-02-28T10:56:36Z

Jalonso:

<source lang="isabelle">
chapter {* R3: Razonamiento sobre programas *}

theory R3_Razonamiento_sobre_programas_alu
imports Main
begin

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

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

text {* ---------------------------------------------------------------
Ejercicio 1.2. Escribir la demostración detallada de
sumaImpares n = n*n
------------------------------------------------------------------- *}

(* benber *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + (2*n+1)"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + (2*n+1)" by (simp only: HI)
also have "... = n*n + (n+n+1)" by (simp only:)
also have "... = n*n + n + n + 1" by (simp only:)
also have "... = n*n + n*1 + n + 1" by (simp only:)
also have "... = n*(n+1) + n + 1"
by (simp only: Nat.add_mult_distrib2)
also have "... = n*(n+1) + (n+1)" by (simp only:)
also have "... = (n+1)*n + (n+1)"
by (simp only: Groups.ab_semigroup_mult_class.mult.commute)
also have "... = (n+1)*n + (n+1)*1" by (simp only: Nat.nat_mult_1_right)
also have "... = (n+1)*(n+1)" by (simp only: Nat.add_mult_distrib2)
also have "... = (Suc n) * (Suc n)" by (simp only: Nat.Suc_eq_plus1)
finally show "sumaImpares (Suc n) = (Suc n) * (Suc n)" .
qed

(* manperjim pabalagon josgomrom4 hugrubsan enrparalv juacanrod *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2 * n + 1"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = n*n + n + n + 1" by (simp only: Nat.add_mult_distrib)
also have "... = (n+1)*n + (n + 1)" by (simp only: Nat.add_mult_distrib)
also have "... = (n+1)*n + (n + 1)*1" by (simp only: Nat.nat_mult_1_right)
also have "... = (n+1)*(n+1)" by (simp only: Nat.add_mult_distrib2)
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)"
by (simp only: Nat.Suc_eq_plus1)
qed

(* marfruman1 raffergon2 aribatval alfmarcua cammonagu gleherlop
chrgencar alikan pabbergue giafus1 antramhur *)
lemma "sumaImpares n = n*n"
proof (induct n)
show "sumaImpares 0 = 0*0" by (simp only: sumaImpares.simps(1))
next
fix n
assume HI: "sumaImpares n = n*n"
have "sumaImpares (Suc n) = sumaImpares n + 2*n +1"
by (simp only: sumaImpares.simps(2))
also have "... = n*n + 2*n + 1" using HI by simp
also have "... = (Suc n)*(Suc n)" by simp
finally show "sumaImpares (Suc n) = (Suc n)*(Suc n)" by simp
qed

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

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

text {* ---------------------------------------------------------------
Ejercicio 2.2. Escribir la demostración detallada de
sumaPotenciasDeDosMasUno n = 2^(n+1)
------------------------------------------------------------------- *}

(* benber josgomrom4 *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
have "sumaPotenciasDeDosMasUno 0 = 2"
by (simp only: sumaPotenciasDeDosMasUno.simps(1))
also have "... = 2^(0+1)" by simp
finally show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)" .
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2^(n+1) + 2^(n+1)" by (simp only: HI)
also have "... = 2 * 2^(n+1)" by (simp only:)
also have "... = 2 * 2^(Suc n)" by (simp only: Nat.Suc_eq_plus1)
also have "... = 2^(Suc (Suc n))"
by (simp only: Power.power_class.power.power_Suc)
also have "... = 2^((Suc n)+1)" by (simp only: Nat.Suc_eq_plus1)
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^((Suc n)+1)" .
qed

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

(* manperjim pabalagon raffergon2 aribatval cammonagu hugrubsan
pabbergue giafus1 antramhur*)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
proof (induct n)
have "sumaPotenciasDeDosMasUno 0 = 2"
by (simp only: sumaPotenciasDeDosMasUno.simps(1))
also have "... = 2^1" by (simp only: Power.power_one_right)
finally show "sumaPotenciasDeDosMasUno 0 = 2^(0+1)"
by (simp only: Nat.add_0)
next
fix n
assume HI: "sumaPotenciasDeDosMasUno n = 2^(n+1)"
have "sumaPotenciasDeDosMasUno (Suc n) =
sumaPotenciasDeDosMasUno n + 2^(n+1)"
by (simp only: sumaPotenciasDeDosMasUno.simps(2))
also have "... = 2^(n+1) + 2^(n+1)" by (simp only: HI)
also have "... = 2*2^(n+1)" by (simp only: Nat.add_mult_distrib)
also have "... = 2*2^(Suc n)" by (simp only: Nat.Suc_eq_plus1)
also have "... = 2^(Suc n)*2^1" by (simp only: Power.power_one_right)
finally show "sumaPotenciasDeDosMasUno (Suc n) = 2^(Suc n + 1)"
by (simp only: Power.power_add)
qed

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

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

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

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

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

(* manperjim benber raffergon2 aribatval josgomrom4 hugrubsan cammonagu
gleherlop chrgencar marfruman1 pabbergue giafus1 juacanrod
antramhur *)
lemma "todos (λy. y=x) (copia n x)"
proof (induct n)
fix x :: 'a
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []"
by (simp only: copia.simps(1))
also have "..." by (simp only: todos.simps(1))
finally show "todos (λy. y = x) (copia 0 x)" .
next
fix x :: 'a
fix n :: nat
assume HI: "todos (λy. y = x) (copia n x)"
have "(todos (λy. y = x) (copia (Suc n) x) ) =
(todos (λy. y = x) (x # copia n x))"
by (simp only: copia.simps(2))
also have "... = (((λy. y = x) x ) ∧ todos (λy. y = x) (copia n x) )"
by (simp only: todos.simps(2))
also have "..." by (simp only: HI)
finally show "todos (λy. y = x) (copia (Suc n) x)" .
qed

(* pabalagon *)
lemma "todos (λy. y=x) (copia n x)"
proof (induction n)
fix x:: 'a
have "todos (λy. y=x) (copia 0 x) = todos (λy. y=x) []" by simp
also have "..." by simp
finally show "todos (λy. y=x) (copia 0 x)" .
next
fix x:: 'a
fix n:: nat
assume HI: "todos (λy. y=x) (copia n x)"
have "todos (λy. y=x) (copia (Suc n) x) =
todos (λy. y=x) (x#(copia n x))" by simp
also have "... = ((λy. y=x) x ∧ todos (λy. y=x) (copia n x))" by simp
finally show "todos (λy. y=x) (copia (Suc n) x)" using HI by simp
qed

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

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

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

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

factI' :: nat ⇒ nat ⇒ nat" where
factI' 0 x = x
factI' (Suc n) x = factI' n (Suc n)*x
Demostrar que, para todo n y todo x, se tiene
factI' n x = x * factR n
Indicación: La propiedad mult_Suc es
(Suc m) * n = n + m * n
Puede que se necesite desactivarla en un paso con
(simp del: mult_Suc)
------------------------------------------------------------------- *}

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

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

(* benber *)
lemma fact: "factI' n x = x * factR n"
proof -
(* Reformulación para aplicar la hipótesis inductiva con un valor
distinto de x. *)
have "∀x. factI' n x = x * factR n"
proof (induct n)
show "∀x. factI' 0 x = x * factR 0"
proof
fix x
have "factI' 0 x = x" by (simp only: factI'.simps(1))
also have "... = x * 1" by (simp only:)
also have "... = x * factR 0" by (simp only: factR.simps(1))
finally show "factI' 0 x = x * factR 0" .
qed
next
show "⋀n. ∀x. factI' n x = x * factR n ⟹
∀x. factI' (Suc n) x = x * factR (Suc n)"
proof
fix x
fix n
assume HI: "∀y. factI' n y = y * factR n"
have "factI' (Suc n) x = factI' n (x * Suc n)"
by (simp only: factI'.simps(2))
also have "... = (x * Suc n) * factR n" by (simp only: HI)
also have "... = x * factR (Suc n)" by (simp only: factR.simps(2))
finally show "factI' (Suc n) x = x * factR (Suc n)" .
qed
qed
thus "factI' n x = x * factR n" by simp
qed

(* manperjim pabalagon raffergon2 aribatval josgomrom4 alfmarcua
hugrubsan cammonagu marfruman1 gleherlop chrgencar pabbergue giafus1
juacanrod antramhur *)
lemma fact2: "factI' n x = x * factR n"
proof (induction n arbitrary: x)
fix x
have "factI' 0 x = x" by simp
also have "... = x * 1" by simp
finally show "factI' 0 x = x * factR 0" by simp
next
fix n
assume HI: "⋀x. factI' n x = x * factR n"
show "⋀x. factI' (Suc n) x = x * factR (Suc n)"
proof -
fix x
have "factI' (Suc n) x = factI' n (x * Suc n)"
by (simp only: factI'.simps(2))
also have "... = x * Suc n * factR n" using HI by simp
finally show "factI' (Suc n) x = x*factR (Suc n)"
by (simp only: factR.simps(2))
qed
qed

text {* ---------------------------------------------------------------
Ejercicio 4.3. Escribir la demostración detallada de
factI n = factR n
------------------------------------------------------------------- *}

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

(* manperjim pabalagon raffergon2 josgomrom4 alfmarcua hugrubsan
marfruman1 gleherlop chrgencar pabbergue giafus1 juacanrod
antramhur *)
corollary "factI n = factR n"
proof -
have "factI n = factI' n 1" by (simp only: factI.simps(1))
also have "... = 1*factR n" using fact by simp
finally show "factI n = factR n" by (simp only: mult_1)
qed

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

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

text {* ---------------------------------------------------------------
Ejercicio 5.2. Escribir la demostración detallada de
amplia xs y = xs @ [y]
------------------------------------------------------------------- *}

(* benber aribatval alfmarcua giafus1 *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
also have "... = [] @ [y]" by (simp only: List.append.left_neutral)
finally show "amplia [] y = [] @ [y]" .
next
fix x
fix xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x # amplia xs y" by (simp only: amplia.simps(2))
also have "... = x # (xs @ [y])" by (simp only: HI)
also have "... = (x#xs) @ [y]" by (simp only: List.append.append_Cons)
finally show "amplia (x#xs) y = (x#xs) @ [y]" .
qed

(* marfruman1 raffergon2 enrparalv alikan gleherlop chrgencar
juacanrod *)
lemma "amplia xs y = xs @ [y]"
proof (induct xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
also have "... = [] @ [y]" by simp
finally show "amplia [] y = [] @ [y]" by simp
next
fix x xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (x#xs) y = x# amplia xs y" by (simp only: amplia.simps(2))
also have "... = x# (xs @ [y])" using HI by simp
also have "... = (x#xs) @ [y]" by simp
finally show "amplia (x#xs) y =(x#xs) @ [y]" by simp
qed

(* manperjim pabalagon josgomrom4 hugrubsan cammonagu pabbergue
antramhur*)
lemma "amplia xs y = xs @ [y]"
proof (induction xs)
have "amplia [] y = [y]" by (simp only: amplia.simps(1))
show "amplia [] y = [] @ [y]" by simp
next
fix a xs
assume HI: "amplia xs y = xs @ [y]"
have "amplia (a#xs) y = a # amplia xs y"
by (simp only: amplia.simps(2))
also have "... = a # (xs @ [y])" using HI by simp
finally show "amplia (a#xs) y = (a#xs) @ [y]" by simp
qed

end
</source>

Relación 2

2019-02-28T10:51:46Z

Jalonso:

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

theory R2_Razonamiento_automatico_sobre_programas_alu
imports Main
begin

declare [[names_short]]

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
hugrubsan enrparalv gleherlop chrgencar giafus1 pabbergue alikan
aribatval *)
fun sumaImpares :: "nat ⇒ nat" where
"sumaImpares 0 = 0" |
"sumaImpares n = 2*n-1 + sumaImpares (n-1)"

value "sumaImpares 1 = 1"
value "sumaImpares 3 = 9"
value "sumaImpares 5 = 25"

(* josgomrom4 marfruman1 benber antramhur *)
fun sumaImpares2 :: "nat ⇒ nat" where
"sumaImpares2 0 = 0" |
"sumaImpares2 (Suc n) = 2*n + 1 + sumaImpares2 n"

value "sumaImpares2 1 = 1"
value "sumaImpares2 3 = 9"
value "sumaImpares2 5 = 25"

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

(* manperjim pabalagon cammonagu juacanrod josgomrom4 hugrubsan
enrparalv gleherlop benber chrgencar giafus1 alikan aribatval *)
lemma "sumaImpares n = n*n"
apply (induction n)
apply auto
done

(* pabalagon *)
lemma "sumaImpares n = n*n"
apply (induction n)
apply simp
apply simp
done

(* pabalagon antramhur *)
lemma "sumaImpares n = n*n"
by (induction n) simp_all

(* alfmarcua raffergon2 marfruman1 pabbergue *)
lemma "sumaImpares n = n*n"
by (induction n) auto

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

(* manperjim pabalagon cammonagu chrgencar hugrubsan gleherlop benber
pabbergue aribatval *)
fun sumaPotenciasDeDosMasUno :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno 0 = 2" |
"sumaPotenciasDeDosMasUno (Suc n) =
2^(n+1) + sumaPotenciasDeDosMasUno n"

value "sumaPotenciasDeDosMasUno 3 = 16"

(* juacanrod josgomrom4 marfruman1 antramhur *)
fun sumaPotenciasDeDosMasUno2 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno2 0 = 2" |
"sumaPotenciasDeDosMasUno2 (Suc n) =
2^(Suc n) + sumaPotenciasDeDosMasUno2 n"

value "sumaPotenciasDeDosMasUno2 3 = 16"

(* alfmarcua raffergon2 enrparalv alikan giafus1 *)
fun sumaPotenciasDeDosMasUno3 :: "nat ⇒ nat" where
"sumaPotenciasDeDosMasUno3 0 = 2" |
"sumaPotenciasDeDosMasUno3 n = 2^n + sumaPotenciasDeDosMasUno3 (n-1)"

value "sumaPotenciasDeDosMasUno3 3 = 16"

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan enrparalv benber chrgencar gleherlop giafus1
pabbergue alikan aribatval *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
apply (induction n)
apply auto
done

(* pabalagon antramhur *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induction n) simp_all

(* marfruman1 *)
lemma "sumaPotenciasDeDosMasUno n = 2^(n+1)"
by (induct n) auto

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

(* manperjim pabalagon cammonagu josgomrom4 hugrubsan benber gleherlop
chrgencar pabbergue alikan antramhur aribatval *)
fun copia :: "nat ⇒ 'a ⇒ 'a list" where
"copia 0 x = []" |
"copia (Suc n) x = x#copia n x"

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

(* juacanrod marfruman1 *)
fun copia2 :: "nat ⇒ 'a ⇒ 'a list" where
"copia2 0 x = []" |
"copia2 (Suc n) x = [x] @ copia2 n x"

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

(* manperjim alfmarcua raffergon2 enrparalv giafus1 *)
fun copia3 :: "nat ⇒ 'a ⇒ 'a list" where
"copia3 0 x = []" |
"copia3 n x = x#(copia (n-1) x)"

value "copia3 3 x = [x,x,x]"

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 marfruman1 hugrubsan enrparalv benber chrgencar giafus1
gleherlop pabbergue alikan antramhur aribatval *)
fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where
"todos p [] = True" |
"todos p (x#xs) = (p x ∧ todos p xs)"

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

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan enrparalv benber giafus1 pabbergue alikan
gleherlop chrgencar aribatval *)
lemma "todos (λy. y=x) (copia n x)"
apply (induction n)
apply auto
done

(* Comentario: La demostración anterior falla para copia3. *)

(* pabalagon antramhur *)
lemma "todos (λy. y=x) (copia n x)"
by (induction n) simp_all

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 marfruman1 hugrubsan enrparalv benber chrgencar gleherlop
giafus1 pabbergue alikan antramhur aribatval *)
fun amplia :: "'a list ⇒ 'a ⇒ 'a list" where
"amplia [] y = [y]" |
"amplia (x#xs) y = x # amplia xs y"

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

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

(* manperjim pabalagon cammonagu juacanrod alfmarcua raffergon2
josgomrom4 hugrubsan gleherlop enrparalv benber chrgencar giafus1
pabbergue alikan aribatval *)
lemma "amplia xs y = xs @ [y]"
apply (induction xs)
apply auto
done

(* pabalagon antramhur *)
lemma "amplia xs y = xs @ [y]"
by (induction xs) simp_all

(* marfruman1 *)
lemma "amplia xs y = xs @ [y]"
by (induction xs) auto

end
</source>

Relación 1

2019-02-28T10:48:27Z

Jalonso:

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

theory R1_Programacion_funcional_en_Isabelle_alu
imports Main
begin

text {* ----------------------------------------------------------------
Ejercicio 1. Definir, por recursión, la función
longitud :: 'a list ⇒ nat
tal que (longitud xs) es la longitud de la listas xs. Por ejemplo,
longitud [a,b,c] = 3
------------------------------------------------------------------- *}

(* cammonagu pabalagon raffergon2 aribatval juacanrod josgomrom4
marfruman1 gleherlop benber alfmarcua enrparlav manperjim chrgencar
antramhur pabbergue alikan*)
fun longitud :: "'a list ⇒ nat" where
"longitud [] = 0 "
| "longitud (x#xs) = 1 + longitud xs "

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

(* hugrubsan giafus1 *)
fun longitud2 :: "'a list ⇒ nat" where
"longitud2 [] = 0 "
| "longitud2 xs = 1 + longitud2 (tl xs) "

value "longitud2 [a,b,c] = 3"

text {* ---------------------------------------------------------------
Ejercicio 2. Definir la función
fun intercambia :: 'a × 'b ⇒ 'b × 'a
tal que (intercambia p) es el par obtenido intercambiando las
componentes del par p. Por ejemplo,
intercambia (u,v) = (v,u)
------------------------------------------------------------------ *}

(* manperjim pabalagon cammonagu raffergon2 aribatval juacanrod
marfruman1 gleherlop benber hugrubsan alfmarcua enrparalv giafus1
chrgencar antramhur alikan pabbergue *)
fun intercambia :: "'a × 'b ⇒ 'b × 'a" where
"intercambia (x,y) = (y, x)"

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

(* josgomrom4 *)
fun intercambia2 :: "'a × 'b ⇒ 'b × 'a" where
"intercambia2 xs = (snd xs, fst xs) "

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

text {* ---------------------------------------------------------------
Ejercicio 3. Definir, por recursión, la función
inversa :: 'a list ⇒ 'a list
tal que (inversa xs) es la lista obtenida invirtiendo el orden de los
elementos de xs. Por ejemplo,
inversa [a,d,c] = [c,d,a]
------------------------------------------------------------------ *}

(* pabalagon *)
fun aux :: "'a list ⇒ 'a list ⇒ 'a list" where
"aux [] a = a"
| "aux (x#xs) a = aux xs (x#a)"

fun inversa :: "'a list ⇒ 'a list" where
"inversa xs = aux xs []"

value "inversa [a,d,c] = [c,d,a]"

(* manperjim pabalagon raffergon2 cammonagu josgomrom4 marfruman1
gleherlop alfmarcua enrparalv chrgencar antramhur alikan pabbergue *)
fun inversa2 :: "'a list ⇒ 'a list" where
"inversa2 [] = []"
| "inversa2 (x#xs) = inversa2 xs @ [x]"

value "inversa2 [a,d,c] = [c,d,a]"

(* juacanrod hugrubsan giafus1 *)
fun inversa3 :: "'a list ⇒ 'a list" where
"inversa3 [] = []"
| "inversa3 (xs) = inversa3(tl xs) @ [ hd (xs)]"

value "inversa3 [a,d,c] = [c,d,a]"

(* aribatval *)
fun inversa4 :: "'a list ⇒ 'a list" where
"inversa4 [] = []"
| "inversa4 xs = last xs # (inversa4 (butlast xs))"

value "inversa4 [a,d,c] = [c,d,a]"

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

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

value "inversa5 [a,d,c] = [c,d,a]"

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

(* pabalag aribatval antramhur *)
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]"

(* manperjim raffergon2 cammonagu josgomrom4 marfruman1 benber alfmarcua
gleherlop giafus1 chrgencar pabbergue alikan *)
fun repite2 :: "nat ⇒ 'a ⇒ 'a list" where
"repite2 0 x = [] "
| "repite2 n x = x # repite2 (n-1) x "

value "repite2 3 a = [a,a,a]"

(* juacanrod hugrubsan *)
fun repite3 :: "nat ⇒ 'a ⇒ 'a list" where
"repite3 0 a = []"
| "repite3 n a = [a] @ repite3 (n-1) a"

value "repite3 3 a = [a,a,a]"

(* enrparalv *)
fun repite4 :: "nat ⇒ 'a ⇒ 'a list" where
"repite4 n x = (if n = 0 then [] else repite4 (n-1) x @ [x])"

value "repite4 3 a = [a,a,a]"

text {* ---------------------------------------------------------------
Ejercicio 5. Definir la función
conc :: 'a list ⇒ 'a list ⇒ 'a list
tal que (conc xs ys) es la concatención de las listas xs e ys. Por
ejemplo,
conc [a,d] [b,d,a,c] = [a,d,b,d,a,c]
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 josgomrom4 aribatval gleherlop
chrgencar benber antramhur*)
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]"

(* cammonagu marfruman1 pabbergue *)
fun conc2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc2 ys [] = ys" |
"conc2 xs (y#ys) = xs @y # ys"

value "conc2 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* juacanrod *)
fun conc3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc3 [] ys = ys" |
"conc3 xs ys = [hd (xs)] @ conc3 (tl (xs)) ys"

value "conc3 [a,d] [b,d,a,c] = [a,d,b,d,a,c]"

(* hugrubsan enrparalv giafus1 alikan *)
fun conc4 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc4 xs ys = xs @ ys"

(* alfmarcua *)
fun conc5 :: "'a list ⇒ 'a list ⇒ 'a list" where
"conc5 [] ys = ys"
| "conc5 xs ys = conc5 (butlast xs) ((last xs)#ys)"

text {* ---------------------------------------------------------------
Ejercicio 6. Definir la función
coge :: nat ⇒ 'a list ⇒ 'a list
tal que (coge n xs) es la lista de los n primeros elementos de xs. Por
ejemplo,
coge 2 [a,c,d,b,e] = [a,c]
------------------------------------------------------------------ *}

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

value "coge 2 [a,c,d,b,e] = [a,c]"

(* manperjim cammonagu josgomrom4 marfruman1 benber alfmarcua chrgencar
gleherlop giafus1 pabbergue *)
fun coge2 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge2 0 xs = []" |
"coge2 n [] = []" |
"coge2 n (x#xs) = x # coge2 (n-1) xs"

value "coge2 2 [a,c,d,b,e] = [a,c]"

(* juacanrod *)
fun coge3 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge3 0 xs = []" |
"coge3 n xs = [hd (xs)] @ coge3 (n-1) (tl (xs))"

value "coge3 2 [a,c,d,b,e] = [a,c]"

(* aribatval hugrubsan *)
fun coge4 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge4 0 xs = []" |
"coge4 n [] = []" |
"coge4 n xs = (hd xs) # coge4 (n-1) (tl xs)"

value "coge4 2 [a,c,d,b,e] = [a,c]"

(* enrparalv *)
fun coge5 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge5 n [] = []"
| "coge5 n (x#xs) = (if (n=0) then [] else [x] @ coge5 (n-1) xs )"

value "coge5 2 [a,c,d,b,e] = [a,c]"

(* alikan *)
fun coge6 :: "nat ⇒ 'a list ⇒ 'a list" where
"coge6 n [] = []"|
"coge6 n (x#xs) = (case n of 0 ⇒ [] | Suc n ⇒ x # coge6 n xs)"

value "coge6 2 [a,c,d,b,e] = [a,c]"

text {* ---------------------------------------------------------------
Ejercicio 7. Definir la función
elimina :: nat ⇒ 'a list ⇒ 'a list
tal que (elimina n xs) es la lista obtenida eliminando los n primeros
elementos de xs. Por ejemplo,
elimina 2 [a,c,d,b,e] = [d,b,e]
------------------------------------------------------------------ *}

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

value "elimina 2 [a,c,d,b,e] = [d,b,e]"

(* manperjim raffergon2 cammonagu josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 pabbergue*)
fun elimina2 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina2 0 xs = xs" |
"elimina2 n [] = []" |
"elimina2 n (x#xs) = elimina2 (n-1) xs"

value "elimina2 2 [a,c,d,b,e] = [d,b,e]"

(* juacanrod hugrubsan *)
fun elimina3 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina3 0 xs = xs" |
"elimina3 n xs = elimina3 (n-1) (tl xs)"

value "elimina3 2 [a,c,d,b,e] = [d,b,e]"

(* alikan *)
fun elimina4 :: "nat ⇒ 'a list ⇒ 'a list" where
"elimina4 n [] = []"|
"elimina4 n (x#xs) = (case n of 0 ⇒ x#xs | Suc n ⇒ elimina4 n xs)"

value "elimina4 2 [a,c,d,b,e] = [d,b,e]"

text {* ---------------------------------------------------------------
Ejercicio 8. Definir la función
esVacia :: 'a list ⇒ bool
tal que (esVacia xs) se verifica si xs es la lista vacía. Por ejemplo,
esVacia [a] = False
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 josgomrom4 marfruman1 benber hugrubsan
alfmarcua enrparalv aribatval chrgencar giafus1 alikan pabbergue
antramhur *)
fun esVacia :: "'a list ⇒ bool" where
"esVacia [] = True" |
"esVacia xs = False"

value "esVacia [a] = False"

(* cammonagu juacanrod *)
fun esVacia2 :: "'a list ⇒ bool" where
"esVacia2 xs = (longitud xs = 0)"

value "esVacia2 [a] = False"

text {* ---------------------------------------------------------------
Ejercicio 9. Definir la función
inversaAc :: 'a list ⇒ 'a list
tal que (inversaAc xs) es a inversa de xs calculada usando
acumuladores. Por ejemplo,
inversaAc [a,c,b,e] = [e,b,c,a]
------------------------------------------------------------------ *}

(* manperjim pabalagon cammonagu josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 alikan pabbergue
antramhur *)
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]"

(* juacanrod *)
fun inversaAcAux2 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux2 [] ys = ys" |
"inversaAcAux2 xs ys = inversaAcAux2 (tl xs) ([hd xs]) @ ys"

value "inversaAcAux2 [a,b,c] []"

fun inversaAc2 :: "'a list ⇒ 'a list" where
"inversaAc2 xs = inversaAcAux2 xs []"

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

(* hugrubsan *)
fun inversaAcAux3 :: "'a list ⇒ 'a list ⇒ 'a list" where
"inversaAcAux3 [] ys = ys"
|"inversaAcAux3 xs ys = inversaAcAux3 (tl xs) [(hd xs)] @ ys"

fun inversaAc3 :: "'a list ⇒ 'a list" where
"inversaAc3 xs = inversaAcAux3 (tl xs) [(hd xs)]"

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

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

(* manperjim pabalagon raffergon2 josgomrom4 marfruman1 benber alfmarcua
enrparalv aribatval gleherlop chrgencar giafus1 pabbergue antramhur
alikan *)
fun sum :: "nat list ⇒ nat" where
"sum [] = 0" |
"sum (x#xs) = x + sum xs"

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

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

value "sum2 [3,2,5] = 10"

(* juacanrod hugrubsan *)
fun sum3 :: "nat list ⇒ nat" where
"sum3 [] = 0" |
"sum3 xs = (hd xs) + sum3 (tl xs)"

value "sum3 [3,2,5,1]"

text {* ---------------------------------------------------------------
Ejercicio 11. Definir la función
map :: ('a ⇒ 'b) ⇒ 'a list ⇒ 'b list
tal que (map f xs) es la lista obtenida aplicando la función f a los
elementos de xs. Por ejemplo,
map (λx. 2*x) [3,2,5] = [6,4,10]
------------------------------------------------------------------ *}

(* manperjim pabalagon raffergon2 cammonagu josgomrom4 marfruman1 benber
alfmarcua aribatval gleherlop chrgencar giafus1 pabbergue antramhur *)
fun map :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map f [] = []" |
"map f (x#xs) = f x # map f xs"

value "map (λn. Suc n) [2,3,4,5]"

(* juacanrod *)
fun map2 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map2 f [] = []" |
"map2 f (x#xs) = [(f x)] @ map2 f xs"

value "map2 (λn. Suc n) [2,3,4,5]"

(* hugrubsan *)
fun map3 :: "('a ⇒ 'b) ⇒ 'a list ⇒ 'b list" where
"map3 f [] = []" |
"map3 f xs = f (hd xs) # map3 f (tl xs)"

value "map3 (λn. Suc n) [2,3,4,5]"

end
</source>

Documentación

2019-02-14T13:21:08Z

Jalonso: /* Otros cursos */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 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.
# J. Gross [https://blogs.ams.org/mathgradblog/2017/10/15/machine-checked-proof Machine-checked proof]. ''AMS Notices'', 15 de octubre de 2017.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# J. Blanchette y J. Höltz [https://lean-forward.github.io/logical-verification/2018 Logical verification]. (Vrije Universiteit Amsterdam, 2018-19).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Recopilaciones/blob/master/Trabajos-MULCIA.org GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Documentación

2019-02-14T13:20:10Z

Jalonso: /* Cursos con Coq */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 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.
# J. Gross [https://blogs.ams.org/mathgradblog/2017/10/15/machine-checked-proof Machine-checked proof]. ''AMS Notices'', 15 de octubre de 2017.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# M. Greenberg [http://www.cs.pomona.edu/~michael/courses/csci054s18/ Discrete mathematics and functional programming].
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Recopilaciones/blob/master/Trabajos-MULCIA.org GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Documentación

2019-02-14T13:19:02Z

Jalonso: /* Cursos con Coq */

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 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.
# J. Gross [https://blogs.ams.org/mathgradblog/2017/10/15/machine-checked-proof Machine-checked proof]. ''AMS Notices'', 15 de octubre de 2017.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations] (Univ. de Pensilvania, 2018).
# G. Smolka [https://courses.ps.uni-saarland.de/icl_18/2/Resources Introduction to computational logic] (Univ. de Sarre, 2018).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Recopilaciones/blob/master/Trabajos-MULCIA.org GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Documentación

2019-02-14T13:16:13Z

Jalonso:

En esta página se recogen en enlaces que sirven de documentación al curso de "Razonamiento automático"

== Vídeos ==

* Vídeos de deducción natural con Pandora: [http://bit.ly/1tqZIOe ejemplo 1] y [http://bit.ly/1nWAVp4 ejemplo 2].

== 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/article/fulltext/sadh/034/01/0003-0025 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.
# J. Gross [https://blogs.ams.org/mathgradblog/2017/10/15/machine-checked-proof Machine-checked proof]. ''AMS Notices'', 15 de octubre de 2017.
# T. Hales. [http://www.ams.org/notices/200811/tx081101370p.pdf Formal proof]. ''Notices of AMS'', Vol. 55, N. 11 (2008) pp. 1370-1380.
# J. Harrison. [http://www.cl.cam.ac.uk/~jrh13/papers/ab.html A short survey of automated reasoning]. ''Lecture Notes in Computer Science'', Vol. 4545, pp. 334-349, 2007.
# J. Harrison. [http://www.ams.org/notices/200811/tx081101395p.pdf Formal proof: Theory and practice]. ''Notices of the AMS'', Vol. 55, N. 11 (2008) p.1395-1406.
# G. Kolata. [http://www.nytimes.com/library/cyber/week/1210math.html Computer math proof shows reasoning power]. ''The New York Times'', 10 de diciembre de 1996.
# D. MacKenzie [http://www.bcs.org/server.php?show=ConWebDoc.4364 Computers and the sociology of mathematical proof].
# G. Sutcliffe. [http://www.cs.miami.edu/~tptp/OverviewOfATP.html What is automated theorem proving?].
# F. Wiedijk [http://www.cs.ru.nl/~freek/100/ Formalizing the «top 100» of mathematical theorems].
# F. Wiedijk [http://www.ams.org/notices/200811/tx081101408p.pdf Formal proof - Getting started]. ''Notices of the AMS'', Vol. 55, n° 11, pp. 1408-1414, 2008.
# F. Wiedijk, [http://mizar.org/trybulec65/8.pdf The QED manifesto revisited]. ''Studies in Logic, Grammar and Rhetoric'', Vol. 10(23), pp. 121-133, 2007.

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [https://isabelle.in.tum.de/doc/prog-prove.pdf Programming and proving in Isabelle/HOL].
# T. Nipkow, M. Wenzel y L.C. Paulson [http://isabelle.in.tum.de/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].
# M. Wenzel [http://isabelle.in.tum.de/doc/isar-ref.pdf The Isabelle/Isar Reference Manual].
# M. Wenzel [http://typessummerschool07.cs.unibo.it/courses/wenzel-isar-quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle].

== Lecturas complementarias ==
=== Programación funcional ===
# J.A. Alonso [https://www.cs.us.es/~jalonso/cursos/i1m-16/temas/2016-17-IM-temas-PF.pdf Temas de "Programación funcional"]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2016.
# 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 [https://www.cs.us.es/~jalonso/cursos/li-15/temas/temas-LI-2015-16.pdf Temas de "Lógica informática" (2015-16)]. Publicaciones del Grupo de Lógica Computacional. Universidad de Sevilla, 2015.
# K. Broda, S. Eisenbach, H. Khoshnevisan y S. Vickers [http://pubs.doc.ic.ac.uk/reasoned-programming/reasoned-programming.pdf Reasoned programming]. Imperial College, 1994.
# K. Doets y J. van Eijck [http://www.ldc.usb.ve/~astorga/Haskell.Road.pdf The Haskell Road to Logic, Maths and Programming].
# M. Huth y M. Ryan [http://bit.ly/2e8dFEm Logic in computer science: Modelling and reasoning about systems]. Cambridge University Press, 2004. (Incluye el [http://www.cs.bham.ac.uk/research/lics/tutor/index.html tutor en la Red]).

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# Jasmin Blanchette, Mathias Fleury y Daniel Wand [http://people.mpi-inf.mpg.de/~jblanche/cswi/ss2015/ Concrete semantics with Isabelle/HOL]. (Univ. del Sarre, 2015-16).
# 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. [http://www.inf.ed.ac.uk/teaching/courses/ar Automated reasoning]. (Univ. de Edimburgo, 2016-17).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www21.in.tum.de/teaching/semantik/WS1617/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow. [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/homepage/de/teaching/SVHOL14/ Specification and Verification with Higher-Order Logic].
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Cursos con Coq ===
# Benjamin C. Pierce et als. [https://softwarefoundations.cis.upenn.edu/lf-current/index.html Software foundations (Vol. 1: Logical foundations)].
# Benjamin C. Pierce [https://www.seas.upenn.edu/~cis500/current/index.html Software foundations].
# 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).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# 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).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).

== Bibliotecas de ejemplos de verificación ==
# [http://afp.sourceforge.net Archive of Formal Proofs].
# [http://www.cs.ru.nl/~freek/100 Formalizing 100 Theorems].
# [http://toccata.lri.fr/gallery Gallery of verified programs].
# [http://automatedreasoning.net/ Larry Wos' Notebooks].
# [http://www.cs.miami.edu/~tptp/ The TPTP Problem Library for Automated Theorem Proving].
# [http://www.macs.hw.ac.uk/vstte10/Competition.html The 1st Verified Software Competition].
# [https://sites.google.com/site/vstte2012/compet The 2nd Verified Software Competition].
# [http://verifythis.cost-ic0701.org VerifyThis (A collection of verification benchmarks].

== Artículos recientes ==

Hay dos listas de artículos recientes:

* en [https://twitter.com/search?f=tweets&q=%23ITP%20OR%20%23IsabelleHOL%20OR%20%23Coq%20OR%20%23Agda%20OR%20%23LeanProver%20OR%20%23MULCIA%20from%3AJose_A_Alonso&src=typd Twitter] que contiene enlaces a los artículos de razonamiento automático y demostración asistida por ordenador que se están publicando y
* en [https://www.glc.us.es/~jalonso/vestigium/category/resena/ Vestigium] que contiene una reseña de los más destacados.

== Ofertas de trabajo ==

En [https://github.com/jaalonso/Recopilaciones/blob/master/Trabajos-MULCIA.org GitHub] se encuentra una recopilaciónn las ofertas de trabajo de interés para los estudiantes del Máster Universitario en Lógica, Computación e Inteligencia Artificial de la Universidad de Sevilla.

Están en orden cronológico inverso por la fecha de su publicación en [https://twitter.com/search?l=&q=%23MULCIA%20from%3AJose_A_Alonso&src=typd&lang=es Twitter].

Tema 6: Lógica en Coq

2019-02-14T13:08:41Z

Jalonso: Protegió «Tema 6: Lógica en Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
Set Warnings "-notation-overridden,-parsing".
Require Export T5_Tacticas.

(* El contenido del tema es
1. Introducción
2. Conectivas lógicas
1. Conjunción
2. Disyunción
3. Falsedad y negación
4. Verdad
5. Equivalencia lógica
6. Cuantificación existencial
3. Programación con proposiciones
4. Aplicando teoremas a argumentos
5. Coq vs. teoría de conjuntos
1. Extensionalidad funcional
2. Proposiciones y booleanos
3. Lógica clásica vs. constructiva
Bibliografía
*)

(* =====================================================================
§ 1. Introducción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1. Calcular el tipo de las siguientes expresiones
3 = 3.
3 = 4.
forall n m : nat, n + m = m + n.
forall n : nat, n = 2.
------------------------------------------------------------------ *)

Check 3 = 3.
(* ===> Prop *)

Check 3 = 4.
(* ===> Prop *)

Check forall n m : nat, n + m = m + n.
(* ===> Prop *)

Check forall n : nat, n = 2.
(* ===> Prop *)

(* ---------------------------------------------------------------------
Nota. El tipo de las fórmulas es Prop.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 1.2.3. Demostrar que 2 más dos es 4.
------------------------------------------------------------------ *)

Theorem suma_2_y_2:
2 + 2 = 4.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Nota. Usa la proposición '2 + 2 = 4'.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 1.2.2. Definir la proposición
prop_suma: Prop
que afirma que la suma de 2 y 2 es 4.
------------------------------------------------------------------ *)

Definition prop_suma: Prop := 2 + 2 = 4.

(* ---------------------------------------------------------------------
Ejemplo 1.2.3. Calcular el tipo de prop_suma
------------------------------------------------------------------ *)

Check prop_suma.
(* ===> prop_suma : Prop *)

(* ---------------------------------------------------------------------
Ejemplo 1.2.4. Usando prop_suma, demostrar que la suma de 2 y 2 es 4.
------------------------------------------------------------------ *)

Theorem prop_suma_es_verdadera:
prop_suma.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.3.1. Definir la proposición
es_tres (n : nat) : Prop
tal que (es_tres n) se verifica si n es el número 3.
------------------------------------------------------------------ *)

Definition es_tres (n : nat) : Prop :=
n = 3.

(* ---------------------------------------------------------------------
Ejemplo 1.3.2. Calcular el tipo de las siguientes expresiones
es_tres.
es_tres 3.
es_tres 5.
------------------------------------------------------------------ *)

Check es_tres.
(* ===> nat -> Prop *)

Check es_tres 3.
(* ===> Prop *)

Check es_tres 5.
(* ===> Prop *)

(* ---------------------------------------------------------------------
Nota. Ejemplo de proposición parametrizada.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 1.4.1. Definir la función
inyectiva {A B : Type} (f : A -> B) : Prop :=
tal que (inyectiva f) se verifica si f es inyectiva.
------------------------------------------------------------------ *)

Definition inyectiva {A B : Type} (f : A -> B) : Prop :=
forall x y : A, f x = f y -> x = y.

(* ---------------------------------------------------------------------
Ejemplo 1.4.2. Demostrar que la funcion sucesor es inyectiva; es
decir,
inyectiva S.
------------------------------------------------------------------ *)

Lemma suc_iny: inyectiva S.
Proof.
intros n m H. (* n, m : nat
H : S n = S m
============================
n = m *)
inversion H. (* n, m : nat
H : S n = S m
H1 : n = m
============================
m = m *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.5. Calcular los tipos de las siguientes expresiones
3 = 5.
eq 3 5.
eq 3.
@eq.
------------------------------------------------------------------ *)

Check (3 = 5).
(* ===> Prop *)

Check (eq 3 5).
(* ===> Prop *)

Check (eq 3).
(* ===> nat -> Prop *)

Check @eq.
(* ===> forall A : Type, A -> A -> Prop *)

(* ---------------------------------------------------------------------
Notas.
1. La expresión (x = y) es una abreviatura de (eq x y).
2. Se escribe @eq en lugar de eq para ver los argumentos implícitos.
------------------------------------------------------------------ *)

(* =====================================================================
§ 2. Conectivas lógicas
================================================================== *)

(* =====================================================================
§§ 2.1. Conjunción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.1. Demostrar que
3 + 4 = 7 /\ 2 * 2 = 4.
------------------------------------------------------------------ *)

Example ej_conjuncion: 3 + 4 = 7 /\ 2 * 2 = 4.
Proof.
split.
- (*
============================
3 + 4 = 7 *)
reflexivity.
- (*
============================
2 * 2 = 4 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. El símbolo de conjunción se escribe con /\
2. La táctica 'split' sustituye el objetivo (P /\ Q) por los
subobjetivos P y Q.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.2. Demostrar que
forall A B : Prop, A -> B -> A /\ B.
------------------------------------------------------------------ *)

Lemma conj_intro: forall A B : Prop, A -> B -> A /\ B.
Proof.
intros A B HA HB. (* A, B : Prop
HA : A
HB : B
============================
A /\ B *)
split.
- (* A, B : Prop
HA : A
HB : B
============================
A *)
apply HA.
- (* A, B : Prop
HA : A
HB : B
============================
B *)
apply HB.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.3. Demostrar, con conj_intro, que
3 + 4 = 7 /\ 2 * 2 = 4.
------------------------------------------------------------------ *)

Example ej_conjuncion': 3 + 4 = 7 /\ 2 * 2 = 4.
Proof.
apply conj_intro.
- (* 3 + 4 = 7 *)
reflexivity.
- (* 2 * 2 = 4 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.4. Demostrar que
forall n m : nat, n = 0 /\ m = 0 -> n + m = 0.
------------------------------------------------------------------ *)

Lemma ej_conjuncion2 :
forall n m : nat, n = 0 /\ m = 0 -> n + m = 0.
Proof.
intros n m H. (* n, m : nat
H : n = 0 /\ m = 0
============================
n + m = 0 *)
destruct H as [Hn Hm]. (* n, m : nat
Hn : n = 0
Hm : m = 0
============================
n + m = 0 *)
rewrite Hn. (* 0 + m = 0 *)
rewrite Hm. (* 0 + 0 = 0 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'destruct H as [HA HB]' que sustituye la
hipótesis H de la forma (A /\ B) por las hipótesis HA (que afirma
que A es verdad) y HB (que afirma que B es verdad).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.5. Demostrar que
forall n m : nat, n = 0 /\ m = 0 -> n + m = 0.
------------------------------------------------------------------ *)

Lemma ej_conjuncion2' :
forall n m : nat, n = 0 /\ m = 0 -> n + m = 0.
Proof.
intros n m [Hn Hm]. (* n, m : nat
Hn : n = 0
Hm : m = 0
============================
n + m = 0 *)
rewrite Hn. (* 0 + m = 0 *)
rewrite Hm. (* 0 + 0 = 0 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. La táctica 'intros x [HA HB]', cuando el objetivo es de la
forma (forall x, A /\ B -> C), introduce la variable x y las
hipótesis HA y HB afirmando la certeza de A y de B, respectivamente.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.6. Demostrar que
forall n m : nat, n = 0 -> m = 0 -> n + m = 0.
------------------------------------------------------------------ *)

Lemma ej_conjuncion2'' :
forall n m : nat, n = 0 -> m = 0 -> n + m = 0.
Proof.
intros n m Hn Hm. (* n, m : nat
Hn : n = 0
Hm : m = 0
============================
n + m = 0 *)
rewrite Hn. (* 0 + m = 0 *)
rewrite Hm. (* 0 + 0 = 0 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.8. Demostrar que
forall P Q : Prop,
P /\ Q -> P.
------------------------------------------------------------------ *)

Lemma conj_e1 : forall P Q : Prop,
P /\ Q -> P.
Proof.
intros P Q [HP HQ]. (* P, Q : Prop
HP : P
HQ : Q
============================
P *)
apply HP.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.9. Demostrar que
forall P Q : Prop,
P /\ Q -> Q /\ P.
------------------------------------------------------------------ *)

Theorem conj_conmutativa: forall P Q : Prop,
P /\ Q -> Q /\ P.
Proof.
intros P Q [HP HQ]. (* P, Q : Prop
HP : P
HQ : Q
============================
Q /\ P *)
split.
- (* P, Q : Prop
HP : P
HQ : Q
============================
Q *)
apply HQ.
- (* P, Q : Prop
HP : P
HQ : Q
============================
P *)
apply HP.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.10. Calcular el tipo de la expresión
and
------------------------------------------------------------------ *)

Check and.
(* ===> and : Prop -> Prop -> Prop *)

(* ---------------------------------------------------------------------
Nota. (x /\ y) es una abreviatura de (and x y).
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.2. Disyunción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.1. Demostrar que
forall n m : nat, n = 0 \/ m = 0 -> n * m = 0.
------------------------------------------------------------------ *)

(* 1ª demostración *)
Lemma disy_ej1:
forall n m : nat, n = 0 \/ m = 0 -> n * m = 0.
Proof.
intros n m H.
destruct H as [Hn | Hm].
- (* n, m : nat
Hn : n = 0
============================
n * m = 0 *)
rewrite Hn. (* 0 * m = 0 *)
reflexivity.
- (* n, m : nat
Hm : m = 0
============================
n * m = 0 *)
rewrite Hm. (* n * 0 = 0 *)
rewrite <- mult_n_O. (* 0 = 0 *)
reflexivity.
Qed.

(* 2ª demostración *)
Lemma disy_ej:
forall n m : nat, n = 0 \/ m = 0 -> n * m = 0.
Proof.
intros n m [Hn | Hm].
- (* n, m : nat
Hn : n = 0
============================
n * m = 0 *)
rewrite Hn. (* 0 * m = 0 *)
reflexivity.
- (* n, m : nat
Hm : m = 0
============================
n * m = 0 *)
rewrite Hm. (* n * 0 = 0 *)
rewrite <- mult_n_O. (* 0 = 0 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. La táctica 'destruct H as [Hn | Hm]', cuando la hipótesis H es de
la forma (A \/ B), la divide en dos casos: uno con hipótesis HA
(afirmando la certeza de A) y otro con la hipótesis HB (afirmando
la certeza de B).
2. La táctica 'intros x [HA | HB]', cuando el objetivo es de la
forma (forall x, A \/ B -> C), intoduce la variable x y dos casos:
uno con hipótesis HA (afirmando la certeza de A) y otro con la
hipótesis HB (afirmando la certeza de B).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.2. Demostrar que
forall A B : Prop, A -> A \/ B.
------------------------------------------------------------------ *)

Lemma disy_intro: forall A B : Prop, A -> A \/ B.
Proof.
intros A B HA. (* A, B : Prop
HA : A
============================
A \/ B *)
left. (* A *)
apply HA.
Qed.

(* ---------------------------------------------------------------------
Nota. La táctica 'left' sustituye el objetivo de la forma (A \/ B)
por A.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.3. Demostrar que
forall n : nat, n = 0 \/ n = S (pred n).
------------------------------------------------------------------ *)

Lemma cero_o_sucesor:
forall n : nat, n = 0 \/ n = S (pred n).
Proof.
intros [|n].
- (*
============================
0 = 0 \/ 0 = S (Nat.pred 0) *)
left. (* 0 = 0 *)
reflexivity.
- (* n : nat
============================
S n = 0 \/ S n = S (Nat.pred (S n)) *)
right. (* S n = S (Nat.pred (S n)) *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. La táctica 'right' sustituye el objetivo de la forma (A \/ B)
por B.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.4. Calcular el tipo de la expresión
or
------------------------------------------------------------------ *)

Check or.
(* ===> or : Prop -> Prop -> Prop *)

(* ---------------------------------------------------------------------
Nota. (x \/ y) es una abreviatura de (or x y).
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.3. Falsedad y negación
================================================================== *)

Module DefNot.

(* ---------------------------------------------------------------------
Ejemplo 2.3.1. Definir la función
not (P : Prop) : Prop
tal que (not P) es la negación de P
------------------------------------------------------------------ *)

Definition not (P:Prop) : Prop :=
P -> False.

(* ---------------------------------------------------------------------
Ejemplo 2.3.2. Definir (~ x) como abreviatura de (not x).
------------------------------------------------------------------ *)

Notation "~ x" := (not x) : type_scope.

(* ---------------------------------------------------------------------
Nota. Esta es la forma como está definida la negación en Coq.
------------------------------------------------------------------ *)

End DefNot.

(* ---------------------------------------------------------------------
Ejemplo 2.3.3. Demostrar que
forall (P:Prop),
False -> P.
------------------------------------------------------------------ *)

Theorem ex_falso_quodlibet: forall (P:Prop),
False -> P.
Proof.
intros P H. (* P : Prop
H : False
============================
P *)
destruct H.
Qed.

(* ---------------------------------------------------------------------
Nota. En latín, "ex falso quodlibet" significa "de lo falso (se
sigue) cualquier cosa".
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.3.4. Demostrar que
~(0 = 1).
------------------------------------------------------------------ *)

Theorem cero_no_es_uno: ~(0 = 1).
Proof.
intros H. (* H : 0 = 1
============================
False *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Nota. La expresión (x <> y) es una abreviatura de ~(x = y).
------------------------------------------------------------------ *)

Theorem cero_no_es_uno': 0 <> 1.
Proof.
intros H. (* H : 0 = 1
============================
False *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.3.5. Demostrar que
~ False
------------------------------------------------------------------ *)

Theorem not_False :
~ False.
Proof.
unfold not. (*
============================
False -> False *)
intros H. (* H : False
============================
False *)
destruct H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.3.6. Demostrar que
forall P Q : Prop,
(P /\ ~P) -> Q.
------------------------------------------------------------------ *)

Theorem contradiccion_implica_cualquiera: forall P Q : Prop,
(P /\ ~P) -> Q.
Proof.
intros P Q [HP HNP]. (* P, Q : Prop
HP : P
HNP : ~ P
============================
Q *)
unfold not in HNP. (* P, Q : Prop
HP : P
HNP : P -> False
============================
Q *)
apply HNP in HP. (* P, Q : Prop
HP : False
HNP : P -> False
============================
Q *)
destruct HP.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.3.7. Demostrar que
forall P : Prop,
P -> ~~P.
------------------------------------------------------------------ *)

Theorem doble_neg: forall P : Prop,
P -> ~~P.
Proof.
intros P H. (* P : Prop
H : P
============================
~ ~ P *)
unfold not. (* (P -> False) -> False *)
intros G. (* P : Prop
H : P
G : P -> False
============================
False *)
apply G. (* P *)
apply H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.3.8. Demostrar que
forall b : bool,
b <> true -> b = false.
------------------------------------------------------------------ *)

(* 1ª demostración *)
Theorem no_verdadero_es_falso: forall b : bool,
b <> true -> b = false.
Proof.
intros [] H.
- (* H : true <> true
============================
true = false *)
unfold not in H. (* H : true = true -> False
============================
true = false *)
apply ex_falso_quodlibet. (* H : true = true -> False
============================
False *)
apply H. (* true = true *)
reflexivity.
- (* H : false <> true
============================
false = false *)
reflexivity.
Qed.

(* 2ª demostración *)
Theorem no_verdadero_es_falso': forall b : bool,
b <> true -> b = false.
Proof.
intros [] H.
- (* H : true <> true
============================
true = false *)
unfold not in H. (* H : true = true -> False
============================
true = false *)
exfalso. (* H : true = true -> False
============================
False *)
apply H. (* true = true *)
reflexivity.
- (* H : false <> true
============================
false = false *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. Uso de 'apply ex_falso_quodlibet' en la primera demostración.
2. Uso de 'exfalso' en la segunda demostración.
3. La táctica 'exfalso' sustituye el objetivo por falso.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.4. Verdad
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.4.1. Demostrar que la proposición True es verdadera.
------------------------------------------------------------------ *)

Lemma True_es_verdadera : True.
Proof.
apply I.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso del constructor I.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.5. Equivalencia lógica
================================================================== *)

Module DefIff.

(* ---------------------------------------------------------------------
Ejemplo 2.5.1. Definir la función
iff (P Q : Prop) : Prop
tal que (iff P Q) es la equivalencia de P y Q.
------------------------------------------------------------------ *)

Definition iff (P Q : Prop) : Prop := (P -> Q) /\ (Q -> P).

(* ---------------------------------------------------------------------
Ejemplo 2.5.2. Definir (P <-> Q) como una abreviatura de (iff P Q).
------------------------------------------------------------------ *)

Notation "P <-> Q" := (iff P Q)
(at level 95, no associativity)
: type_scope.

End DefIff.

(* ---------------------------------------------------------------------
Ejemplo 2.5.3. Demostrar que
forall P Q : Prop,
(P <-> Q) -> (Q <-> P).
------------------------------------------------------------------ *)

Theorem iff_sim : forall P Q : Prop,
(P <-> Q) -> (Q <-> P).
Proof.
intros P Q [HPQ HQP]. (* P, Q : Prop
HPQ : P -> Q
HQP : Q -> P
============================
Q <-> P *)
split.
- (* P, Q : Prop
HPQ : P -> Q
HQP : Q -> P
============================
Q -> P *)
apply HQP.
- (* P, Q : Prop
HPQ : P -> Q
HQP : Q -> P
============================
P -> Q *)
apply HPQ.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.5.4. Demostrar que
forall b : bool,
b <> true <-> b = false.
------------------------------------------------------------------ *)

Lemma not_true_iff_false : forall b : bool,
b <> true <-> b = false.
Proof.
intros b. (* b : bool
============================
b <> true <-> b = false *)
split.
- (* b : bool
============================
b <> true -> b = false *)
apply no_verdadero_es_falso.
- (* b : bool
============================
b = false -> b <> true *)
intros H. (* b : bool
H : b = false
============================
b <> true *)
rewrite H. (* false <> true *)
intros H'. (* b : bool
H : b = false
H' : false = true
============================
False *)
inversion H'.
Qed.

(* ---------------------------------------------------------------------
Nota. Se importa la librería Coq.Setoids.Setoid para usar las
tácticas reflexivity y rewrite con iff.
------------------------------------------------------------------ *)

Require Import Coq.Setoids.Setoid.

(* ---------------------------------------------------------------------
Ejercicio 2.2.1. Demostrar que
forall n m, n * m = 0 -> n = 0 \/ m = 0.
------------------------------------------------------------------ *)

Lemma mult_eq_0 :
forall n m, n * m = 0 -> n = 0 \/ m = 0.
Proof.
intros n m H. (* n, m : nat
H : n * m = 0
============================
n = 0 \/ m = 0 *)
destruct n as [|n'].
- (* m : nat
H : 0 * m = 0
============================
0 = 0 \/ m = 0 *)
left. (* 0 = 0 *)
reflexivity.
- (* n', m : nat
H : S n' * m = 0
============================
S n' = 0 \/ m = 0 *)
destruct m as [|m'].
+ (* n' : nat
H : S n' * 0 = 0
============================
S n' = 0 \/ 0 = 0 *)
right. (* 0 = 0 *)
reflexivity.
+ (* n', m' : nat
H : S n' * S m' = 0
============================
S n' = 0 \/ S m' = 0 *)
simpl in H. (* n', m' : nat
H : S (m' + n' * S m') = 0
============================
S n' = 0 \/ S m' = 0 *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.5.5. Demostrar que
forall n m : nat, n * m = 0 <-> n = 0 \/ m = 0.
------------------------------------------------------------------ *)

Lemma mult_0 : forall n m : nat, n * m = 0 <-> n = 0 \/ m = 0.
Proof.
split.
- (* n, m : nat
============================
n * m = 0 -> n = 0 \/ m = 0 *)
apply mult_eq_0.
- (* n, m : nat
============================
n = 0 \/ m = 0 -> n * m = 0 *)
apply disy_ej.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.5.6. Demostrar que
forall P Q R : Prop,
P \/ (Q \/ R) <-> (P \/ Q) \/ R.
------------------------------------------------------------------ *)

Lemma disy_asociativa :
forall P Q R : Prop, P \/ (Q \/ R) <-> (P \/ Q) \/ R.
Proof.
intros P Q R. (* P, Q, R : Prop
============================
P \/ (Q \/ R) <-> (P \/ Q) \/ R *)
split.
- (* P, Q, R : Prop
============================
P \/ (Q \/ R) -> (P \/ Q) \/ R *)
intros [H | [H | H]].
+ (* P, Q, R : Prop
H : P
============================
(P \/ Q) \/ R *)
left. (* P \/ Q *)
left. (* P *)
apply H.
+ (* P, Q, R : Prop
H : Q
============================
(P \/ Q) \/ R *)
left. (* P \/ Q *)
right. (* Q *)
apply H.
+ (* P, Q, R : Prop
H : R
============================
(P \/ Q) \/ R *)
right. (* R *)
apply H.
- (* P, Q, R : Prop
============================
(P \/ Q) \/ R -> P \/ (Q \/ R) *)
intros [[H | H] | H].
+ (* P, Q, R : Prop
H : P
============================
(P \/ Q) \/ R *)
left. (* P *)
apply H.
+ (* P, Q, R : Prop
H : Q
============================
P \/ (Q \/ R) *)
right. (* Q \/ R *)
left. (* Q *)
apply H.
+ (* P, Q, R : Prop
H : R
============================
P \/ (Q \/ R) *)
right. (* Q \/ R *)
right. (* R *)
apply H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.5.7. Demostrar que
forall n m p : nat,
n * m * p = 0 <-> n = 0 \/ m = 0 \/ p = 0.
------------------------------------------------------------------ *)

Lemma mult_0_3: forall n m p : nat,
n * m * p = 0 <-> n = 0 \/ m = 0 \/ p = 0.
Proof.
intros n m p. (* n, m, p : nat
============================
n * (m * p) = 0 <-> n = 0 \/ (m = 0 \/ p = 0) *)
rewrite mult_0. (* n * m = 0 \/ p = 0 <->
n = 0 \/ (m = 0 \/ p = 0) *)
rewrite mult_0. (* (n = 0 \/ m = 0) \/ p = 0 <->
n = 0 \/ (m = 0 \/ p = 0) *)
rewrite disy_asociativa. (* (n = 0 \/ m = 0) \/ p = 0 <->
(n = 0 \/ m = 0) \/ p = 0 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de reflexivity y rewrite con iff.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.5.8. Demostrar que
forall n m : nat,
n * m = 0 -> n = 0 \/ m = 0.
------------------------------------------------------------------ *)

Lemma ej_apply_iff: forall n m : nat,
n * m = 0 -> n = 0 \/ m = 0.
Proof.
intros n m H. (* n, m : nat
H : n * m = 0
============================
n = 0 \/ m = 0 *)
apply mult_0. (* n * m = 0 *)
apply H.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de apply sobre iff.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.6. Cuantificación existencial
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.6.1. Demostrar que
exists n : nat, 4 = n + n.
------------------------------------------------------------------ *)

Lemma cuatro_es_par: exists n : nat, 4 = n + n.
Proof.
exists 2. (*
============================
4 = 2 + 2 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. La táctica 'exists a' sustituye el objetivo de la forma
(exists x, P(x)) por P(a).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.6.2. Demostrar que
forall n : nat,
(exists m, n = 4 + m) -> (exists o, n = 2 + o).
------------------------------------------------------------------ *)

(* 1ª demostración *)
Theorem ej_existe_2a: forall n : nat,
(exists m, n = 4 + m) ->
(exists o, n = 2 + o).
Proof.
intros n H. (* n : nat
H : exists m : nat, n = 4 + m
============================
exists o : nat, n = 2 + o *)
destruct H as [a Ha]. (* n, a : nat
Ha : n = 4 + a
============================
exists o : nat, n = 2 + o *)
exists (2 + a). (* n = 2 + (2 + a) *)
apply Ha.
Qed.

(* 2ª demostración *)
Theorem ej_existe_2b: forall n : nat,
(exists m, n = 4 + m) ->
(exists o, n = 2 + o).
Proof.
intros n [a Ha]. (* n, a : nat
Ha : n = 4 + a
============================
exists o : nat, n = 2 + o *)
exists (2 + a). (* n = 2 + (2 + a) *)
apply Ha.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. 'destruct H [a Ha]' sustituye la hipótesis (H : exists x, P(x))
por (Ha : P(a)).
2. 'intros x [a Ha]' sustituye el objetivo
(forall x, (exists y P(y)) -> Q(x)) por Q(x) y le añade la
hipótesis (Ha : P(a)).
------------------------------------------------------------------ *)

(* =====================================================================
§ 3. Programación con proposiciones
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 3.1.1. Definir la función
En {A : Type} (x : A) (xs : list A) : Prop :=
tal que (En x xs) se verifica si x pertenece a xs.
------------------------------------------------------------------ *)

Fixpoint En {A : Type} (x : A) (xs : list A) : Prop :=
match xs with
| [] => False
| x' :: xs' => x' = x \/ En x xs'
end.

(* ---------------------------------------------------------------------
Ejemplo 3.1.2. Demostrar que
En 4 [1; 2; 3; 4; 5].
------------------------------------------------------------------ *)

Example En_ejemplo_1 : En 4 [1; 2; 3; 4; 5].
Proof.
simpl. (* 1 = 4 \/ 2 = 4 \/ 3 = 4 \/ 4 = 4 \/ 5 = 4 \/ False *)
right. (* 2 = 4 \/ 3 = 4 \/ 4 = 4 \/ 5 = 4 \/ False *)
right. (* 3 = 4 \/ 4 = 4 \/ 5 = 4 \/ False *)
right. (* 4 = 4 \/ 5 = 4 \/ False *)
left. (* 4 = 4 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.1.3. Demostrar que
forall n : nat,
En n [2; 4] -> exists n', n = 2 * n'.
------------------------------------------------------------------ *)

Example En_ejemplo_2: forall n : nat,
En n [2; 4] -> exists n', n = 2 * n'.
Proof.
simpl. (*
============================
forall n : nat,
2 = n \/ 4 = n \/ False ->
exists n' : nat, n = n' + (n' + 0) *)
intros n [H | [H | []]].
- (* n : nat
H : 2 = n
============================
exists n' : nat, n = n' + (n' + 0) *)
exists 1. (* n = 1 + (1 + 0) *)
rewrite <- H. (* 2 = 1 + (1 + 0) *)
reflexivity.
- (* n : nat
H : 4 = n
============================
exists n' : nat, n = n' + (n' + 0) *)
exists 2. (* n = 2 + (2 + 0) *)
rewrite <- H. (* 4 = 2 + (2 + 0) *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso del patrón vacío para descartar el último caso.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 3.2. Demostrar que
forall (A B : Type) (f : A -> B) (xs : list A) (x : A),
En x xs ->
En (f x) (map f xs).
------------------------------------------------------------------ *)

Lemma En_map: forall (A B : Type) (f : A -> B) (xs : list A) (x : A),
En x xs ->
En (f x) (map f xs).
Proof.
intros A B f xs x. (* A : Type
B : Type
f : A -> B
xs : list A
x : A
============================
En x xs -> En (f x) (map f xs) *)
induction xs as [|x' xs' HI].
- (* A : Type
B : Type
f : A -> B
x : A
============================
En x [ ] -> En (f x) (map f [ ]) *)
simpl. (* False -> False *)
intros [].
- (* A : Type
B : Type
f : A -> B
x' : A
xs' : list A
x : A
HI : En x xs' -> En (f x) (map f xs')
============================
En x (x'::xs') ->
En (f x) (map f (x'::xs')) *)
simpl. (* x' = x \/ En x xs' ->
f x' = f x \/ En (f x) (map f xs') *)
intros [H | H].
+ (* A : Type
B : Type
f : A -> B
x' : A
xs' : list A
x : A
HI : En x xs' -> En (f x) (map f xs')
H : x' = x
============================
f x' = f x \/ En (f x) (map f xs') *)
rewrite H. (* f x = f x \/ En (f x) (map f xs') *)
left. (* f x = f x *)
reflexivity.
+ (* A : Type
B : Type
f : A -> B
x' : A
xs' : list A
x : A
HI : En x xs' -> En (f x) (map f xs')
H : En x xs'
============================
f x' = f x \/ En (f x) (map f xs') *)
right. (* En (f x) (map f xs') *)
apply HI. (* En x xs' *)
apply H.
Qed.

(* =====================================================================
§ 4. Aplicando teoremas a argumentos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 4.1. Evaluar la expresión
Check suma_conmutativa.
------------------------------------------------------------------ *)

Check suma_conmutativa.
(* ===> forall n m : nat, n + m = m + n *)

(* ---------------------------------------------------------------------
Notas.
1. En Coq, las demostraciones son objetos de primera clase.
2. Coq devuelve el tipo de suma_conmutativa como el de cualquier
expresión.
3. El identificador suma_conmutativa representa un objeto prueba de
(forall n m : nat, n + m = m + n).
4. Un término de tipo (nat -> nat -> nat) transforma dos naturales en
un natural.
5. Análogamente, un término de tipo (n = m -> n + n = m + m)
transforma un argumento de tipo (n = m) en otro de tipo
(n + n = m + m).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 4.2. Demostrar que
forall x y z : nat,
x + (y + z) = (z + y) + x.
------------------------------------------------------------------ *)

(* 1º intento *)
Lemma suma_conmutativa3a :
forall x y z : nat,
x + (y + z) = (z + y) + x.
Proof.
intros x y z. (* x, y, z : nat
============================
x + (y + z) = (z + y) + x *)
rewrite suma_conmutativa. (* (y + z) + x = (z + y) + x *)
rewrite suma_conmutativa. (* x + (y + z) = (z + y) + x *)
Abort.

(* 2º intento *)
Lemma suma_conmutativa3b :
forall x y z,
x + (y + z) = (z + y) + x.
Proof.
intros x y z. (* x, y, z : nat
============================
x + (y + z) = z + y + x *)
rewrite suma_conmutativa. (* (y + z) + x = (z + y) + x *)
assert (H : y + z = z + y).
- (* x, y, z : nat
============================
y + z = z + y *)
rewrite suma_conmutativa. (* z + y = z + y *)
reflexivity.
- (* x, y, z : nat
H : y + z = z + y
============================
(y + z) + x = (z + y) + x *)
rewrite H. (* (z + y) + x = (z + y) + x *)
reflexivity.
Qed.

(* 3º intento *)
Lemma suma_conmutativa3c:
forall x y z,
x + (y + z) = (z + y) + x.
Proof.
intros x y z. (* x, y, z : nat
============================
x + (y + z) = (z + y) + x *)
rewrite suma_conmutativa. (* (y + z) + x = (z + y) + x *)
rewrite (suma_conmutativa y z). (* (z + y) + x = (z + y) + x *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Indicación en (rewrite (suma_conmutativa y z)) de los
argumentos con los que se aplica, análogamente a las funciones
polimórficas.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 4.3. Demostrar que
forall {n : nat} {ns : list nat},
En n (map (fun m => m * 0) ns) ->
n = 0.
------------------------------------------------------------------ *)

(* Lema auxiliar *)
Lemma producto_n_0:
forall n : nat, n * 0 = 0.
Proof.
induction n as [|n' HI].
- (*
============================
0 * 0 = 0 *)
reflexivity.
- (* n' : nat
HI : n' * 0 = 0
============================
S n' * 0 = 0 *)
simpl. (* n' * 0 = 0 *)
apply HI.
Qed.

(* Lema auxiliar. *)
Lemma En_map_iff: forall (A B : Type) (f : A -> B) (xs : list A) (y : B),
En y (map f xs) <->
exists x, f x = y /\ En x xs.
Proof.
intros A B f xs y. (* A : Type
B : Type
f : A -> B
xs : list A
y : B
============================
En y (map f xs) <->
(exists x : A, f x = y /\ En x xs) *)
induction xs as [|x xs' HI].
- (* A : Type
B : Type
f : A -> B
y : B
============================
En y (map f [ ]) <->
(exists x : A, f x = y /\ En x [ ]) *)
simpl. (* En y (map f [ ]) <->
(exists x : A, f x = y /\ En x [ ]) *)
split.
+ (* A : Type
B : Type
f : A -> B
y : B
============================
False ->
exists x : A, f x = y /\ False *)
intros [].
+ (* A : Type
B : Type
f : A -> B
y : B
============================
(exists x : A, f x = y /\ False) ->
False *)
intros [a [H []]].
- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
============================
En y (map f (x :: xs')) <->
(exists x0 : A,
f x0 = y /\ En x0 (x :: xs')) *)
simpl. (* f x = y \/ En y (map f xs') <->
(exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs')) *)
split.
+ (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
============================
f x = y \/ En y (map f xs') ->
exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs') *)
intros [H1 | H2].
* (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
H1 : f x = y
============================
exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs') *)
exists x. (* f x = y /\ (x = x \/ En x xs') *)
split.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
H1 : f x = y
============================
f x = y *)
apply H1.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
H1 : f x = y
============================
x = x \/ En x xs' *)
left. (* x = x *)
reflexivity.
* (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
H2 : En y (map f xs')
============================
exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs') *)
apply HI in H2. (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
H2 : exists x : A, f x = y /\ En x xs'
============================
exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs') *)
destruct H2 as [a [Ha1 Ha2]]. (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha2 : En a xs'
============================
exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs') *)

exists a. (* En y (map f xs) <->
(exists x : A, f x = y /\ En x xs) *)
split.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha2 : En a xs'
============================
f a = y *)
apply Ha1.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha2 : En a xs'
============================
x = a \/ En a xs' *)
right. (* En a xs' *)
apply Ha2.
+ (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x : A,
f x = y /\ En x xs')
============================
(exists x0 : A,
f x0 = y /\ (x = x0 \/ En x0 xs')) ->
f x = y \/ En y (map f xs') *)
intros [a [Ha1 [Ha2 | Ha3]]].
* (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha2 : x = a
============================
f x = y \/ En y (map f xs') *)
left. (* f x = y *)
rewrite Ha2. (* f a = y *)
rewrite Ha1. (* y = y *)
reflexivity.
* (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha3 : En a xs'
============================
f x = y \/ En y (map f xs') *)
right. (* En y (map f xs') *)
apply HI. (* exists x0 : A, f x0 = y /\ En x0 xs' *)
exists a. (* f a = y /\ En a xs' *)
split.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha3 : En a xs'
============================
f a = y *)
apply Ha1.
-- (* A : Type
B : Type
f : A -> B
x : A
xs' : list A
y : B
HI : En y (map f xs') <->
(exists x:A, f x = y /\ En x xs')
a : A
Ha1 : f a = y
Ha3 : En a xs'
============================
En a xs' *)
apply Ha3.
Qed.

(* 1ª demostración *)
Example ej_aplicacion_de_lema_1:
forall {n : nat} {ns : list nat},
En n (map (fun m => m * 0) ns) ->
n = 0.
Proof.
intros n ns H. (* n : nat
ns : list nat
H : En n (map (fun m : nat => m * 0) ns)
============================
n = 0 *)
rewrite En_map_iff in H. (* n : nat
ns : list nat
H : exists x : nat, x * 0 = n /\ En x ns
============================
n = 0 *)
destruct H as [m [Hm _]]. (* n : nat
ns : list nat
m : nat
Hm : m * 0 = n
============================
n = 0 *)
rewrite producto_n_0 in Hm. (* n : nat
ns : list nat
m : nat
Hm : 0 = n
============================
n = 0 *)
symmetry. (* 0 = n *)
apply Hm.
Qed.

(* 2ª demostración *)
Example ej_aplicacion_de_lema:
forall {n : nat} {ns : list nat},
En n (map (fun m => m * 0) ns) ->
n = 0.
Proof.
intros n ns H. (* n : nat
ns : list nat
H : En n (map (fun m : nat => m * 0) ns)
============================
n = 0 *)
destruct (conj_e1 _ _
(En_map_iff _ _ _ _ _)
H)
as [m [Hm _]]. (* n : nat
ns : list nat
H : En n (map (fun m : nat => m * 0) ns)
m : nat
Hm : m * 0 = n
============================
n = 0 *)
rewrite producto_n_0 in Hm. (* n : nat
ns : list nat
H : En n (map (fun m : nat => m * 0) ns)
m : nat
Hm : 0 = n
============================
n = 0 *)
symmetry. (* 0 = n *)
apply Hm.
Qed.

(* ---------------------------------------------------------------------
Nota. Aplicación de teoremas a argumentos con
(conj_e1 _ _ (En_map_iff _ _ _ _ _) H)
------------------------------------------------------------------ *)

(* =====================================================================
§ 5. Coq vs. teoría de conjuntos
================================================================== *)

(* ---------------------------------------------------------------------
Notas.
1. En lugar de decir que un elemento pertenece a un conjunto se puede
decir que verifica la propiedad que define al conjunto.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 5.1. Extensionalidad funcional
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 5.1.1. Demostrar que
plus 3 = plus (pred 4).
------------------------------------------------------------------ *)

Example igualdad_de_funciones_ej1:
suma 3 = suma (pred 4).
Proof.
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.1.2. Definir el axioma de extensionalidad funcional que
afirma que dos funciones son giuales cuando tienen los mismos
valores.
------------------------------------------------------------------ *)

Axiom extensionalidad_funcional : forall {X Y: Type}
{f g : X -> Y},
(forall (x:X), f x = g x) -> f = g.

(* ---------------------------------------------------------------------
Ejemplo 5.1.3. Demostrar que
(fun x => suma x 1) = (fun x => suma 1 x).
------------------------------------------------------------------ *)

Example igualdad_de_funciones_ej2 :
(fun x => suma x 1) = (fun x => suma 1 x).
Proof.
apply extensionalidad_funcional. (*
============================
forall x : nat, suma x 1 = suma 1 x *)
intros x. (* x : nat
============================
suma x 1 = suma 1 x *)
apply suma_conmutativa.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. No se puede demostrar sin el axioma.
2. Hay que ser cuidadoso en la definición de axiomas, porque se
pueden introducir inconsistencias.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 5.1.4. Calcular los axiomas usados en la prueba de
igualdad_de_funciones_ej2
------------------------------------------------------------------ *)

Print Assumptions igualdad_de_funciones_ej2.
(* ===>
Axioms:
extensionalidad_funcional :
forall (X Y : Type) (f g : X -> Y),
(forall x : X, f x = g x) -> f = g *)
(* =====================================================================
§§ 5.2. Proposiciones y booleanos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 5.2.1. Demostrar que
forall k : nat,
esPar (doble k) = true.
------------------------------------------------------------------ *)

Theorem esPar_doble:
forall k : nat, esPar (doble k) = true.
Proof.
intros k. (* k : nat
============================
esPar (doble k) = true *)
induction k as [|k' HI].
- (*
============================
esPar (doble 0) = true *)
reflexivity.
- (* k' : nat
HI : esPar (doble k') = true
============================
esPar (doble (S k')) = true *)
simpl. (* esPar (doble k') = true *)
apply HI.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.2.2. Demostrar que
forall n : nat,
esPar n = true <-> exists k, n = doble k.

Es decir, que la computación booleana (esPar n) refleja la
proposición (exists k, n = doble k).
------------------------------------------------------------------ *)

(* Lema auxiliar. *)
Lemma esPar_doble_aux :
forall n : nat,
exists k : nat, n = if esPar n
then doble k
else S (doble k).
Proof.
induction n as [|n' HI].
- (*
============================
exists k : nat,
0 = (if esPar 0
then doble k
else S (doble k)) *)
exists 0. (* 0 = (if esPar 0
then doble 0
else S (doble 0)) *)
reflexivity.
- (* n' : nat
HI : exists k : nat,
n' = (if esPar n'
then doble k
else S (doble k))
============================
exists k : nat,
S n' = (if esPar (S n')
then doble k
else S (doble k)) *)
destruct (esPar n') eqn:H.
+ (* n' : nat
H : esPar n' = true
HI : exists k : nat, n' = doble k
============================
exists k : nat,
S n' = (if esPar (S n')
then doble k
else S (doble k)) *)
rewrite esPar_S. (* exists k : nat,
S n' = (if negacion (esPar n')
then doble k
else S (doble k)) *)
rewrite H. (* exists k : nat,
S n' = (if negacion true
then doble k
else S (doble k)) *)
simpl. (* exists k : nat, S n' = S (doble k) *)
destruct HI as [k' Hk']. (* n' : nat
H : esPar n' = true
k' : nat
Hk' : n' = doble k'
============================
exists k : nat, S n' = S (doble k) *)
exists k'. (* S n' = S (doble k') *)
rewrite Hk'. (* S (doble k') = S (doble k') *)
reflexivity.
+ (* n' : nat
H : esPar n' = false
HI : exists k : nat, n' = S (doble k)
============================
exists k : nat,
S n' = (if esPar (S n')
then doble k
else S (doble k)) *)
rewrite esPar_S. (* exists k : nat,
S n' = (if negacion (esPar n')
then doble k
else S (doble k)) *)
rewrite H. (* exists k : nat,
S n' = (if negacion false
then doble k
else S (doble k)) *)
simpl. (* exists k : nat, S n' = doble k *)
destruct HI as [k' Hk']. (* n' : nat
H : esPar n' = false
k' : nat
Hk' : n' = S (doble k')
============================
exists k : nat, S n' = doble k *)
exists (1 + k'). (* S n' = doble (1 + k') *)
rewrite Hk'. (* S (S (doble k')) = doble (1 + k') *)
reflexivity.
Qed.

Theorem esPar_bool_prop:
forall n : nat,
esPar n = true <-> exists k, n = doble k.
Proof.
intros n. (* n : nat
============================
esPar n = true <-> (exists k : nat, n = doble k) *)
split.
- (* n : nat
============================
esPar n = true -> exists k : nat, n = doble k *)
intros H. (* n : nat
H : esPar n = true
============================
exists k : nat, n = doble k *)
destruct
(esPar_doble_aux n)
as [k Hk]. (* n : nat
H : esPar n = true
k : nat
Hk : n = (if esPar n then doble k else S (doble k))
============================
exists k0 : nat, n = doble k0 *)
rewrite Hk. (* exists k0 : nat,
(if esPar n
then doble k
else S (doble k))
= doble k0 *)
rewrite H. (* exists k0 : nat, doble k = doble k0 *)
exists k. (* doble k = doble k *)
reflexivity.
- (* n : nat
============================
(exists k : nat, n = doble k) -> esPar n = true *)
intros [k Hk]. (* n, k : nat
Hk : n = doble k
============================
esPar n = true *)
rewrite Hk. (* esPar (doble k) = true *)
apply esPar_doble.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.2.3. Demostrar que
forall n m : nat,
iguales_nat n m = true <-> n = m.
------------------------------------------------------------------ *)

Theorem iguales_nat_bool_prop:
forall n m : nat,
iguales_nat n m = true <-> n = m.
Proof.
intros n m. (* n, m : nat
============================
iguales_nat n m = true <-> n = m *)
split.
- (* n, m : nat
============================
iguales_nat n m = true -> n = m *)
apply iguales_nat_true.
- (* n, m : nat
============================
n = m -> iguales_nat n m = true *)
intros H. (* n, m : nat
H : n = m
============================
iguales_nat n m = true *)
rewrite H. (* iguales_nat m m = true *)
rewrite iguales_nat_refl. (* true = true *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.2.4. Definir la función es_primo_par tal que
(es_primo_par n) es verifica si n es un primo par.
------------------------------------------------------------------ *)

(* 1º intento *)
Fail Definition es_primo_par n :=
if n = 2
then true
else false.

(* 2º intento *)
Definition es_primo_par n :=
if iguales_nat n 2
then true
else false.

(* ---------------------------------------------------------------------
Ejemplo 5.2.5.1. Demostrar que
exists k : nat, 1000 = doble k.
------------------------------------------------------------------ *)

Example esPar_1000: exists k : nat, 1000 = doble k.
Proof.
exists 500.
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.2.5.2. Demostrar que
esPar 1000 = true.
------------------------------------------------------------------ *)

Example esPar_1000' : esPar 1000 = true.
Proof.
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.2.5.3. Demostrar que
exists k : nat, 1000 = doble k.
------------------------------------------------------------------ *)

Example esPar_1000'': exists k : nat, 1000 = doble k.
Proof.
apply esPar_bool_prop. (* esPar 1000 = true *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. En la proposicional se necesita proporcionar un testipo.
2. En la booleano se calcula sin testigo.
3. Se puede demostrar la proposicional usando la equivalencia con la
booleana sin necesidad de testigo.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 5.3. Lógica clásica vs. constructiva
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 5.3.1. Definir la proposicion
tercio_excluso
que afirma que (forall P : Prop, P \/ ~ P).
------------------------------------------------------------------ *)

Definition tercio_excluso : Prop := forall P : Prop,
P \/ ~ P.

(* ---------------------------------------------------------------------
Nota. La proposición tercio_excluso no es demostrable en Coq.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 5.3.2. Demostrar que
forall (P : Prop) (b : bool),
(P <-> b = true) -> P \/ ~ P.
------------------------------------------------------------------ *)

Theorem tercio_exluso_restringido :
forall (P : Prop) (b : bool),
(P <-> b = true) -> P \/ ~ P.
Proof.
intros P [] H.
- (* P : Prop
H : P <-> true = true
============================
P \/ ~ P *)
left. (* P *)
rewrite H. (* true = true *)
reflexivity.
- (* P : Prop
H : P <-> false = true
============================
P \/ ~ P *)
right. (* ~ P *)
rewrite H. (* false <> true *)
intros H1. (* H1 : false = true
============================
False *)
inversion H1.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.3.3. Demostrar que
forall (n m : nat),
n = m \/ n <> m.
------------------------------------------------------------------ *)

Theorem tercio_exluso_restringido_eq:
forall (n m : nat),
n = m \/ n <> m.
Proof.
intros n m. (* n, m : nat
============================
n = m \/ n <> m *)
apply (tercio_exluso_restringido
(n = m)
(iguales_nat n m)). (* n = m <-> iguales_nat n m = true *)
symmetry. (* iguales_nat n m = true <-> n = m *)
apply iguales_nat_bool_prop.
Qed.

(* ---------------------------------------------------------------------
Notas.
1. En Coq no se puede demostrar el principio del tercio exluso.
2. Las demostraciones de las fórmulas existenciales tienen que
proporcionar un testigo.
2. La lógica de Coq es constructiva.
------------------------------------------------------------------ *)

(* =====================================================================
§ Bibliografía
================================================================== *)

(*
+ "Logic in Coq" de Peirce et als. http://bit.ly/2nv1T9Z *)
</source>

Tema 7: Definiciones inductivas en Coq

2019-02-14T13:08:12Z

Jalonso: Protegió «Tema 7: Definiciones inductivas en Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
(* T7: Proposiciones definidas inductivamente *)

Set Warnings "-notation-overridden,-parsing".
Require Export T6_Logica.
Require Coq.omega.Omega.

(* El contenido del tema es
1. Proposiciones definidas inductivamente.
2. Usando evidencias en demostraciones.
1. Inversión sobre evidencias.
2. Inducción sobre evidencias.
3. Relaciones inductivas.
*)

(* =====================================================================
§ 1. Proposiciones definidas inductivamente.
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1. Definir inductivamente la proposición
es_par: nat -> Prop
tal que (es_par n) expresa que n es un número par.
------------------------------------------------------------------ *)

Inductive es_par: nat -> Prop :=
| es_par_0 : es_par 0
| es_par_SS : forall n : nat, es_par n -> es_par (S (S n)).

(* ---------------------------------------------------------------------
Ejemplo 1.2. Demostrar que
es_par 4.
------------------------------------------------------------------ *)

(* 1ª demostración *)
Theorem es_par_4: es_par 4.
Proof.
apply es_par_SS. (* es_par 2 *)
apply es_par_SS. (* es_par 0 *)
apply es_par_0.
Qed.

(* 2ª demostración *)
Theorem es_par_4': es_par 4.
Proof.
apply (es_par_SS 2 (es_par_SS 0 es_par_0)).
Qed.

(* Nota *)
Check es_par_0. (* es_par 0 *)
Check es_par_SS. (* forall n : nat,
es_par n -> es_par (S (S n)) *)
Check (es_par_SS 0). (* es_par 0 -> es_par 2 *)
Check (es_par_SS 0 es_par_0). (* es_par 2 *)
Check (es_par_SS 2). (* es_par 2 -> es_par 4 *)
Check (es_par_SS 2 (es_par_SS 0 es_par_0)). (* es_par 4 *)

(* ---------------------------------------------------------------------
Ejemplo 1.3. Demostrar que
forall n : nat, es_par n -> es_par (4 + n).
------------------------------------------------------------------ *)

Theorem es_par_suma4:
forall n : nat, es_par n -> es_par (4 + n).
Proof.
intros n. (* n : nat
============================
es_par n -> es_par (4 + n) *)
simpl. (* es_par n -> es_par (S (S (S (S n)))) *)
intros Hn. (* Hn : es_par n
============================
es_par (S (S (S (S n)))) *)
apply es_par_SS. (* es_par (S (S n)) *)
apply es_par_SS. (* es_par n *)
apply Hn.
Qed.

(* =====================================================================
§ 2. Usando evidencias en demostraciones
================================================================== *)

(* ---------------------------------------------------------------------
Nota. Programación y demostración en Coq son dos lados de la misma
moneda. En programación se procesan datos y en demostración se
procesan evidencias.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.1. Inversión sobre evidencias
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.1. Demostrar que
forall n : nat,
es_par n -> es_par (pred (pred n)).
------------------------------------------------------------------ *)

(* 1ª demostración *)
Theorem es_par_menos_2:
forall n : nat,
es_par n -> es_par (pred (pred n)).
Proof.
intros n E. (* n : nat
E : es_par n
============================
es_par (Nat.pred (Nat.pred n)) *)
inversion E as [| n' E'].
- (* H : 0 = n
============================
es_par (Nat.pred (Nat.pred 0)) *)
simpl. (* es_par 0 *)
apply es_par_0.
- (* n' : nat
E' : es_par n'
H : S (S n') = n
============================
es_par (Nat.pred (Nat.pred (S (S n')))) *)
simpl. (* es_par n' *)
apply E'.
Qed.

(* ---------------------------------------------------------------------
Nota. La táctica (inversion E), donde E es la etiqueta de una
proposición P definida inductivamente, genera para cada uno de los
constructores de P las condiciones bajo las que se puede usar el
constructor para demostrar P.
------------------------------------------------------------------ *)

(* 2ª demostración *)
Theorem es_par_menos_2':
forall n : nat,
es_par n -> es_par (pred (pred n)).
Proof.
intros n E. (* n : nat
E : es_par n
============================
es_par (Nat.pred (Nat.pred n)) *)
destruct E as [| n' E'].
- (* es_par (Nat.pred (Nat.pred 0)) *)
simpl. (* es_par 0 *)
apply es_par_0.
- (* E' : es_par n'
============================
es_par (Nat.pred (Nat.pred (S (S n')))) *)
simpl. (* es_par n' *)
apply E'.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de destruct sobre evidencia con (destruct E as [| n' E']).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.2. Demostrar que
forall n : nat,
es_par (S (S n)) -> es_par n.
------------------------------------------------------------------ *)

(* 1º intento *)
Theorem es_parSS_es_par:
forall n : nat,
es_par (S (S n)) -> es_par n.
Proof.
intros n E. (* n : nat
E : es_par (S (S n))
============================
es_par n *)
destruct E as [| n' E'].
- (* n : nat
============================
es_par n *)
Abort.

(* ---------------------------------------------------------------------
Nota. Mal funcionamiento de destruct sobre evidencias de términos
compuestos.
------------------------------------------------------------------ *)

(* 2º intento *)
Theorem es_parSS_es_par:
forall n : nat,
es_par (S (S n)) -> es_par n.
Proof.
intros n E. (* n : nat
E : es_par (S (S n))
============================
es_par n *)
inversion E as [| n' E']. (* n' : nat
E' : es_par n
H : n' = n
============================
es_par n *)
apply E'.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.1.3. Demostrar que
~ es_par 1.
------------------------------------------------------------------ *)

Theorem uno_no_es_par:
~ es_par 1.
Proof.
intros H. (* H : es_par 1
============================
False *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de inversión sobre evidencia para contradicción.
------------------------------------------------------------------ *)

(* =====================================================================
§§ 2.2. Inducción sobre evidencias
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.1. Demostrar que
forall n : nat,
es_par n -> exists k, n = doble k.
------------------------------------------------------------------ *)

(* 1º intento*)
Lemma es_par_par_1:
forall n : nat,
es_par n -> exists k, n = doble k.
Proof.
intros n E. (* n : nat
E : es_par n
============================
exists k : nat, n = doble k *)
inversion E as [| n' E'].
- (* H : 0 = n
============================
exists k : nat, 0 = doble k *)
exists 0. (* 0 = doble 0 *)
reflexivity.
- (* n' : nat
E' : es_par n'
H : S (S n') = n
============================
exists k : nat, S (S n') = doble k *)
simpl. (* exists k : nat, S (S n') = doble k *)
assert (I : (exists k', n' = doble k') ->
(exists k, S (S n') = doble k)).
+ (* (exists k' : nat, n' = doble k') ->
exists k : nat, S (S n') = doble k *)
intros [k' Hk']. (* k' : nat
Hk' : n' = doble k'
============================
exists k : nat, S (S n') = doble k *)
rewrite Hk'. (* exists k : nat, S (S (doble k')) = doble k *)
exists (S k'). (* S (S (doble k')) = doble (S k') *)
reflexivity.
+ (* I : (exists k' : nat, n' = doble k') ->
exists k : nat, S (S n') = doble k
============================
exists k : nat, S (S n') = doble k *)
apply I. (* exists k' : nat, n' = doble k' *)
Abort.

(* 2º intento *)
Lemma es_par_par:
forall n : nat,
es_par n -> exists k, n = doble k.
Proof.
intros n E. (* n : nat
E : es_par n
============================
exists k : nat, n = doble k *)
induction E as [|n' E' HI].
- (* exists k : nat, 0 = doble k *)
exists 0. (* 0 = doble 0 *)
reflexivity.
- (* n' : nat
E' : es_par n'
HI : exists k : nat, n' = doble k
============================
exists k : nat, S (S n') = doble k *)
destruct HI as [k' Hk']. (* k' : nat
Hk' : n' = doble k'
============================
exists k : nat, S (S n') = doble k *)
rewrite Hk'. (* exists k : nat, S (S (doble k')) = doble k *)
exists (S k'). (* S (S (doble k')) = doble (S k') *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.2.2. Demostrar que
forall n : nat,
es_par n <-> exists k, n = doble k.
------------------------------------------------------------------ *)

Lemma es_par_doble:
forall n : nat, es_par (doble n).
Proof.
induction n as [|n' HI].
- (* es_par (doble 0) *)
simpl. (* es_par 0 *)
apply es_par_0.
- (* n' : nat
HI : es_par (doble n')
============================
es_par (doble (S n')) *)
simpl. (* es_par (S (S (doble n'))) *)
apply es_par_SS. (* es_par (doble n') *)
apply HI.
Qed.

Theorem es_par_par_syss:
forall n : nat,
es_par n <-> exists k, n = doble k.
Proof.
intros n. (* n : nat
============================
es_par n <-> (exists k : nat, n = doble k) *)
split.
- (* es_par n -> exists k : nat, n = doble k *)
apply es_par_par.
- (* (exists k : nat, n = doble k) -> es_par n *)
intros [k Hk]. (* n, k : nat
Hk : n = doble k
============================
es_par n *)
rewrite Hk. (* es_par (doble k) *)
apply es_par_doble.
Qed.

(* =====================================================================
§ 3. Relaciones inductivas
================================================================== *)

(* ---------------------------------------------------------------------
Notas.
1. Las proposiciones con un argumento definen conjuntos; por ejemplo,
es_par define el conjunto de los números pares.
2. Las proposiciones con dos argumento definen relaciones.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Nota. Creamos el módulo para redefinir la relación menor o igual
(definida por le) como menOig.
------------------------------------------------------------------ *)

Module RelInd.

(* ---------------------------------------------------------------------
Ejemplo 3.1. Definir inductivamente la relación
menOig: nat -> nat -> Prop
tal que (menOig n m) expresa que n es menor o igual que m.
------------------------------------------------------------------ *)

Inductive menOig: nat -> nat -> Prop :=
| menOig_n : forall n, menOig n n
| menOig_S : forall n m, (menOig n m) -> (menOig n (S m)).

(* ---------------------------------------------------------------------
Ejemplo 3.2. Definir (m <= n) como abreviatura de (menOig m n).
------------------------------------------------------------------ *)

Notation "m <= n" := (menOig m n).

(* ---------------------------------------------------------------------
Nota. Sobre la relaciones (p.e. <=) se pueden usar las mismas
tácticas que sobre las propiedades (p.e. es_par).
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 3.3. Demostrar que
3 <= 3.
------------------------------------------------------------------ *)

Theorem prop_menOig1:
3 <= 3.
Proof.
apply menOig_n.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.4. Demostrar que
3 <= 6.
------------------------------------------------------------------ *)

Theorem prop_menOig2 :
3 <= 6.
Proof.
apply menOig_S. (* 3 <= 5 *)
apply menOig_S. (* 3 <= 4 *)
apply menOig_S. (* 3 <= 3 *)
apply menOig_n.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.5. Demostrar que
(2 <= 1) -> 2 + 2 = 5.
------------------------------------------------------------------ *)

Theorem prop_menOig3 :
(2 <= 1) -> 2 + 2 = 5.
Proof.
intros H. (* H : 2 <= 1
============================
2 + 2 = 5 *)
inversion H. (* n, m : nat
H2 : 2 <= 0
H1 : n = 2
H0 : m = 0
============================
2 + 2 = 5 *)
inversion H2.
Qed.

End RelInd.

(* ---------------------------------------------------------------------
Nota. En lo que sigue, usaremos la predefiida le en lugar de menOig.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 3.6. Definir la relación
mayor : nat -> nat -> Prop
tal que (menor m n) expresa que m es menor que n.
------------------------------------------------------------------ *)

Definition menor (n m : nat) := le (S n) m.

(* ---------------------------------------------------------------------
Ejemplo 3.7. Definir la abreviatura (m < n) para (menor m n).
------------------------------------------------------------------ *)

Notation "m < n" := (menor m n).

(* ---------------------------------------------------------------------
Ejemplo 3.8. Definir inductivamente la relación
cuadrado_de: nat -> nat -> Prop :=
tal que (cuadrado x y) expresa que y es el cuadrado de x.
------------------------------------------------------------------ *)

Inductive cuadrado_de: nat -> nat -> Prop :=
| cuad : forall n : nat, cuadrado_de n (n * n).

(* ---------------------------------------------------------------------
Ejemplo 3.9. Definir inductivamente la relación
siguiente_nat : nat -> nat -> Prop
tal que (siguiente_nat x y) expresa que y es el siguiente de x.
------------------------------------------------------------------ *)

Inductive siguiente_nat : nat -> nat -> Prop :=
| sn : forall n : nat, siguiente_nat n (S n).

(* ---------------------------------------------------------------------
Ejemplo 3.9. Definir inductivamente la relación
siguiente_par : nat -> nat -> Prop :=
tal que (siguiente_par x y) expresa que y es el siguiente número par
de x.
------------------------------------------------------------------ *)

Inductive siguiente_par : nat -> nat -> Prop :=
| sp_1 : forall n, es_par (S n) -> siguiente_par n (S n)
| sp_2 : forall n, es_par (S (S n)) -> siguiente_par n (S (S n)).

(* =====================================================================
§ Bibliografía
=====================================================================

+ "Inductively defined propositions" de Peirce et als.
http://bit.ly/2Lejw7s *)
</source>

Tema 7: Definiciones inductivas en Coq

2019-02-14T13:08:00Z

Jalonso: Página creada con «<source lang="coq"> (* T7: Proposiciones definidas inductivamente *) Set Warnings "-notation-overridden,-parsing". Require Export T6_Logica. Require Coq.omega.Omega. (* E…»

Temas

2019-02-14T13:07:31Z

Jalonso:

En esta página se irán publicando los temas conforme se vayan estudiando.

== RA con Isabelle/HOL ==
* [[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: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-1.pdf Tema 7a: Sintaxis y semántica de la lógica proposicional].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7b: Deducción natural proposicional].
** [[Tema 7b: Deducción natural proposicional con Isabelle/HOL | Tema 7c: Deducción natural proposicional con Isabelle/HOL]].
* Tema 8: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-7.pdf Tema 8a: Sintaxis y semántica de la lógica de primer orden].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 8b: Deducción natural en lógica de primer orden].
** [[Tema 8b: Deducción natural en lógica de primer orden con Isabelle/HOL | Tema 8c: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 9: Editores lógicos]].
* [[Tema 10: Caso de estudio: Compilación de expresiones]].
* [[Tema 11: Definiciones inductivas]].
* [[Tema 12: Conjuntos, funciones y relaciones]].

== RA con Coq ==
* [[Tema 1: Programación funcional y métodos elementales de demostración en Coq]].
* [[Tema 2: Demostraciones por inducción sobre los números naturales en Coq]].
* [[Tema 3: Datos estructurados en Coq]].
* [[Tema 4: Polimorfismo y funciones de orden superior en Coq]].
* [[Tema 5: Tácticas básicas de Coq]].
* [[Tema 6: Lógica en Coq]].
* [[Tema 7: Definiciones inductivas en Coq]].

Tema 6: Lógica en Coq

2019-02-14T12:46:50Z

Jalonso: Página creada con «<source lang="coq"> Set Warnings "-notation-overridden,-parsing". Require Export T5_Tacticas. (* El contenido del tema es 1. Introducción 2. Conectivas lógicas…»

Temas

2019-02-14T12:46:19Z

Jalonso:

En esta página se irán publicando los temas conforme se vayan estudiando.

== RA con Isabelle/HOL ==
* [[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: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-1.pdf Tema 7a: Sintaxis y semántica de la lógica proposicional].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7b: Deducción natural proposicional].
** [[Tema 7b: Deducción natural proposicional con Isabelle/HOL | Tema 7c: Deducción natural proposicional con Isabelle/HOL]].
* Tema 8: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-7.pdf Tema 8a: Sintaxis y semántica de la lógica de primer orden].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 8b: Deducción natural en lógica de primer orden].
** [[Tema 8b: Deducción natural en lógica de primer orden con Isabelle/HOL | Tema 8c: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 9: Editores lógicos]].
* [[Tema 10: Caso de estudio: Compilación de expresiones]].
* [[Tema 11: Definiciones inductivas]].
* [[Tema 12: Conjuntos, funciones y relaciones]].

== RA con Coq ==
* [[Tema 1: Programación funcional y métodos elementales de demostración en Coq]].
* [[Tema 2: Demostraciones por inducción sobre los números naturales en Coq]].
* [[Tema 3: Datos estructurados en Coq]].
* [[Tema 4: Polimorfismo y funciones de orden superior en Coq]].
* [[Tema 5: Tácticas básicas de Coq]].
* [[Tema 6: Lógica en Coq]].

Tema 11: Definiciones inductivas

2019-02-14T07:37:45Z

Jalonso: Protegió «Tema 11: Definiciones inductivas» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="isabelle">
chapter {* Tema 11: Definiciones inductivas *}

theory T11_Definiciones_inductivas
imports Main
begin

section {* El conjunto de los números pares *}

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

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

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

subsection {* Definición inductiva del conjunto de los pares *}

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

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

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

subsection {* Uso de las reglas de introducción *}

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

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

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

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

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

lemma even_imp_par: "even n ⟹ n ∈ par"
by auto

subsection {* Regla de inducción *}

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

text {*
Lema: Los números pares son divisibles por 2.
*}

― ‹1ª demostración (detallada)›
lemma par_imp_even:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "2 dvd (0::nat)" by (simp_all add: dvd_def)
next
fix n::nat
assume H1: "n ∈ par" and
H2: "even n"
have "∃k. n = 2*k" using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k" ..
then have "Suc (Suc n) = 2*(k+1)" by auto
then have "∃k. Suc (Suc n) = 2*k" ..
then show "even (Suc (Suc n))" by (simp add: dvd_def)
qed

― ‹2ª demostración (con arith)›
lemma par_imp_even_2:
"n ∈ par ⟹ even n"
proof (induction rule: par.induct)
show "even (0::nat)" by (simp_all add: dvd_def)
next
fix n::nat
assume H1: "n ∈ par" and
H2: "even n"
then show "even (Suc (Suc n))" by (auto simp add: dvd_def, arith)
qed

― ‹3ª demostración (automática)›
lemma par_imp_even_3:
"n ∈ par ⟹ even n"
by (induction rule:par.induct) (auto simp add: dvd_def, arith)

text {*
Lema: Un número n es par syss es divisible por 2.
*}

theorem par_iff_even: "(n ∈ par) = (even n)"
by (blast intro: even_imp_par par_imp_even)

subsection{* Generalización y regla de inducción *}

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

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

· El siguiente intento falla:
*}

lemma "Suc (Suc n) ∈ par ⟹ n ∈ par"
apply (erule par.induct)
oops

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

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

text {*
Reformulación del lema: Si n es par, entonces n-2 también lo es.
*}

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

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

text {*
Con el lema anterior se puede demostrar el original.
*}

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

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

(* Comentar el uso de drule *)

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

text {*
Lemma. Un número natural n es par syss n+2 es par.
*}

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

text {*
Se usa el atributo "iff" porque sirve como regla de simplificación.
*}

subsection {* Definiciones mutuamente inductivas *}

text {*
Definición cruzada de los conjuntos inductivos de los pares y de los
impares:
*}

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

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

text {*
Ejemplo de demostración usando el esquema anterior.
*}

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

subsection {* Definición inductiva de predicados *}

text {*
Definición inductiva del predicado es_par tal que (es_par n) se
verifica si n es par.
*}

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

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

end
</source>

Tema 12: Conjuntos, funciones y relaciones

2019-02-14T07:37:27Z

Jalonso: Protegió «Tema 12: Conjuntos, funciones y relaciones» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

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

theory T12_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›

value "∑{2::nat,5,3}" ― ‹= 10›

definition sumaCuadradosConj :: "nat set ⇒ nat" where
"sumaCuadradosConj S ≡ ∑x∈S. x*x"

value "sumaCuadradosConj {2,5,3}" ― ‹= 38›

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

declare sumaConj_def [simp]
declare sumaCuadradosConj_def [simp]

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

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

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

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

― ‹La demostración 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"
then have "y ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
next
assume "y ≠ x"
then have "y ∈ F" using `y ∈ insert x F` by simp
then have "y ≤ sumaConj F" using HI by blast
also have "… ≤ x + (sumaConj F)" by simp
also have "… = sumaConj (insert x F)" using fF xF by simp
finally show ?thesis .
qed
qed
qed

subsection {* Definiciones por comprensión *}

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

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

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

lemma "{x. P x ∨ x ∈ A} = {x. P x} ∪ A"
by 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)"
then have "x ∈ Pares" by (rule IntD1)
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" by (rule IntD2)
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

― ‹La demostración estructurada es›
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
then have "x ∈ Pares" ..
then have "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" ..
then have "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

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

― ‹La demostración estructurada es›
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
then show "g = h" using `inj f` by (simp add: inj_on_def fun_eq_iff)
next
assume "g = h"
then show "f ∘ g = f ∘ h" by auto
qed

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

Tema 5: Tácticas básicas de Coq

2019-02-14T07:37:09Z

Jalonso: Protegió «Tema 5: Tácticas básicas de Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
Set Warnings "-notation-overridden,-parsing".
Require Export T4_PolimorfismoyOS.
Require Export R2_Induccion_sol.

(* El contenido del tema es
1. La táctica 'apply'
2. La táctica 'apply ... with ...'
3. La táctica 'inversion'
4. Uso de tácticas sobre las hipótesis
5. Control de la hipótesis de inducción
6. Expansión de definiciones
7. Uso de 'destruct' sobre expresiones compuestas
8. Resumen de tácticas básicas
*)

(* =====================================================================
§ 1. La táctica 'apply'
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1. Demostrar que
n = m ->
[n;o] = [n;p] ->
[n;o] = [m;p].
------------------------------------------------------------------ *)

(* Demostración sin apply *)
Theorem artificial_1a : forall (n m o p : nat),
n = m ->
[n;o] = [n;p] ->
[n;o] = [m;p].
Proof.
intros n m o p H1 H2. (* n, m, o, p : nat
H1 : n = m
H2 : [n; o] = [n; p]
============================
[n; o] = [m; p] *)
rewrite <- H1. (* [n; o] = [n; p] *)
rewrite H2. (* [n; p] = [n; p] *)
reflexivity.
Qed.

(* Demostración con apply *)
Theorem artificial_1b : forall (n m o p : nat),
n = m ->
[n;o] = [n;p] ->
[n;o] = [m;p].
Proof.
intros n m o p H1 H2. (* n, m, o, p : nat
H1 : n = m
H2 : [n; o] = [n; p]
============================
[n; o] = [m; p] *)
rewrite <- H1. (* [n; o] = [n; p] *)
apply H2.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'apply'.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 1.2. Demostrar que
n = m ->
(forall (q r : nat), q = r -> [q;o] = [r;p]) ->
[n;o] = [m;p].
------------------------------------------------------------------ *)

Theorem artificial2 : forall (n m o p : nat),
n = m ->
(forall (q r : nat), q = r -> [q;o] = [r;p]) ->
[n;o] = [m;p].
Proof.
intros n m o p H1 H2. (* n, m, o, p : nat
H1 : n = m
H2 : forall q r : nat, q = r -> [q; o] = [r; p]
============================
[n; o] = [m; p] *)
apply H2. (* n = m *)
apply H1.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'apply' en hipótesis condicionales y
razonamiento hacia atrás
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 1.3. Demostrar que
(n,n) = (m,m) ->
(forall (q r : nat), (q,q) = (r,r) -> [q] = [r]) ->
[n] = [m].
------------------------------------------------------------------ *)

Theorem artificial2a : forall (n m : nat),
(n,n) = (m,m) ->
(forall (q r : nat), (q,q) = (r,r) -> [q] = [r]) ->
[n] = [m].
Proof.
intros n m H1 H2. (* n, m : nat
H1 : (n, n) = (m, m)
H2 : forall q r : nat, (q, q) = (r, r) -> [q] = [r]
============================
[n] = [m] *)
apply H2. (* (n, n) = (m, m) *)
apply H1.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.4. Demostrar que
true = iguales_nat n 5 ->
iguales_nat (S (S n)) 7 = true.
------------------------------------------------------------------ *)

Theorem artificial3a: forall (n : nat),
true = iguales_nat n 5 ->
iguales_nat (S (S n)) 7 = true.
Proof.
intros n H. (* n : nat
H : true = iguales_nat n 5
============================
iguales_nat (S (S n)) 7 = true *)
symmetry. (* true = iguales_nat (S (S n)) 7 *)
simpl. (* true = iguales_nat n 5 *)
apply H.
Qed.

(* ---------------------------------------------------------------------
Nota. Necesidad de usar symmetry antes de apply.
------------------------------------------------------------------ *)

(* =====================================================================
§ 2. La táctica 'apply ... with ...'
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1. Demostrar que
forall (a b c d e f : nat),
[a;b] = [c;d] ->
[c;d] = [e;f] ->
[a;b] = [e;f].
------------------------------------------------------------------ *)

Example ejemplo_con_transitiva: forall (a b c d e f : nat),
[a;b] = [c;d] ->
[c;d] = [e;f] ->
[a;b] = [e;f].
Proof.
intros a b c d e f H1 H2. (* a, b, c, d, e, f : nat
H1 : [a; b] = [c; d]
H2 : [c; d] = [e; f]
============================
[a; b] = [e; f] *)
rewrite -> H1. (* [c; d] = [e; f] *)
rewrite -> H2. (* [e; f] = [e; f] *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.2. Demostrar que
forall (X : Type) (n m o : X),
n = m -> m = o -> n = o.
------------------------------------------------------------------ *)

Theorem igualdad_transitiva: forall (X:Type) (n m o : X),
n = m -> m = o -> n = o.
Proof.
intros X n m o H1 H2. (* X : Type
n, m, o : X
H1 : n = m
H2 : m = o
============================
n = o *)
rewrite -> H1. (* m = o *)
rewrite -> H2. (* o = o *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. El ejercicio 2.2 es una generalización del 2.1, sus
demostraciones son isomorfas y se puede usar el 2.2 en la
demostración del 2.1.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 2.3. Demostrar que
forall (X : Type) (n m o : X),
n = m -> m = o -> n = o.
------------------------------------------------------------------ *)

(* 1ª demostración *)
Example ejemplo_con_transitiva' : forall (a b c d e f : nat),
[a;b] = [c;d] ->
[c;d] = [e;f] ->
[a;b] = [e;f].
Proof.
intros a b c d e f H1 H2. (* a, b, c, d, e, f : nat
H1 : [a; b] = [c; d]
H2 : [c; d] = [e; f]
============================
[a; b] = [e; f] *)
apply igualdad_transitiva with (m:=[c;d]).
- (* [a; b] = [c; d] *)
apply H1.
- (* [c; d] = [e; f] *)
apply H2.
Qed.

(* 2ª demostración *)
Example ejemplo_con_transitiva'' : forall (a b c d e f : nat),
[a;b] = [c;d] ->
[c;d] = [e;f] ->
[a;b] = [e;f].
Proof.
intros a b c d e f H1 H2. (* a, b, c, d, e, f : nat
H1 : [a; b] = [c; d]
H2 : [c; d] = [e; f]
============================
[a; b] = [e; f] *)
apply igualdad_transitiva with [c;d].
- (* [a; b] = [c; d] *)
apply H1.
- (* [c; d] = [e; f] *)
apply H2.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'apply ... whith ...'
------------------------------------------------------------------ *)

(* =====================================================================
§ 3. La táctica 'inversion'
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 3.1. Demostrar que
forall (n m : nat),
S n = S m -> n = m.
------------------------------------------------------------------ *)

Theorem S_inyectiva: forall (n m : nat),
S n = S m ->
n = m.
Proof.
intros n m H. (* n, m : nat
H : S n = S m
============================
n = m *)
inversion H. (* n, m : nat
H : S n = S m
H1 : n = m
============================
m = m *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'inversion'
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 3.2. Demostrar que
forall (n m o : nat),
[n; m] = [o; o] -> [n] = [m].
------------------------------------------------------------------ *)

Theorem inversion_ej1: forall (n m o : nat),
[n; m] = [o; o] ->
[n] = [m].
Proof.
intros n m o H. (* n, m, o : nat
H : [n; m] = [o; o]
============================
[n] = [m] *)
inversion H. (* n, m, o : nat
H : [n; m] = [o; o]
H1 : n = o
H2 : m = o
============================
[o] = [o] *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.3. Demostrar que
forall (n m : nat),
[n] = [m] ->
n = m.
------------------------------------------------------------------ *)

Theorem inversion_ej2: forall (n m : nat),
[n] = [m] ->
n = m.
Proof.
intros n m H. (* n, m : nat
H : [n] = [m]
============================
n = m *)
inversion H as [Hnm]. (* n, m : nat
H : [n] = [m]
Hnm : n = m
============================
m = m *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Nombramiento de las hipótesis generadas por inversión.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 3.4. Demostrar que
forall n:nat,
iguales_nat 0 n = true -> n = 0.
------------------------------------------------------------------ *)

Theorem iguales_nat_0_n: forall n:nat,
iguales_nat 0 n = true -> n = 0.
Proof.
intros n. (* n : nat
============================
iguales_nat 0 n = true -> n = 0 *)
destruct n as [| n'].
- (*
============================
iguales_nat 0 0 = true -> 0 = 0 *)
intros H. (* H : iguales_nat 0 0 = true
============================
0 = 0 *)
reflexivity.
- (* n' : nat
============================
iguales_nat 0 (S n') = true -> S n' = 0 *)
simpl. (* n' : nat
============================
false = true -> S n' = 0 *)
intros H. (* n' : nat
H : false = true
============================
S n' = 0 *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.5. Demostrar que
forall (n : nat),
S n = O -> 2 + 2 = 5.
------------------------------------------------------------------ *)

Theorem inversion_ej4: forall (n : nat),
S n = O ->
2 + 2 = 5.
Proof.
intros n H. (* n : nat
H : S n = 0
============================
2 + 2 = 5 *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.6. Demostrar que
forall (n m : nat),
false = true -> [n] = [m].
------------------------------------------------------------------ *)

Theorem inversion_ej5: forall (n m : nat),
false = true -> [n] = [m].
Proof.
intros n m H. (* n, m : nat
H : false = true
============================
[n] = [m] *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.7. Demostrar que
forall (A B : Type) (f: A -> B) (x y: A),
x = y -> f x = f y.
------------------------------------------------------------------ *)

Theorem funcional: forall (A B : Type) (f: A -> B) (x y: A),
x = y -> f x = f y.
Proof.
intros A B f x y H. (* A : Type
B : Type
f : A -> B
x, y : A
H : x = y
============================
f x = f y *)
rewrite H. (* f y = f y *)
reflexivity.
Qed.

(* =====================================================================
§ 4. Uso de tácticas sobre las hipótesis
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 4.1. Demostrar que
forall (n m : nat) (b : bool),
iguales_nat (S n) (S m) = b ->
iguales_nat n m = b.
------------------------------------------------------------------ *)

Theorem S_inj: forall (n m : nat) (b : bool),
iguales_nat (S n) (S m) = b ->
iguales_nat n m = b.
Proof.
intros n m b H. (* n, m : nat
b : bool
H : iguales_nat (S n) (S m) = b
============================
iguales_nat n m = b *)
simpl in H. (* n, m : nat
b : bool
H : iguales_nat n m = b
============================
iguales_nat n m = b *)
apply H.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de táctica 'simpl in ...'
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 4.1. Demostrar que
forall (n : nat),
(iguales_nat n 5 = true -> iguales_nat (S (S n)) 7 = true) ->
true = iguales_nat n 5 ->
true = iguales_nat (S (S n)) 7.
------------------------------------------------------------------ *)

Theorem artificial3': forall (n : nat),
(iguales_nat n 5 = true -> iguales_nat (S (S n)) 7 = true) ->
true = iguales_nat n 5 ->
true = iguales_nat (S (S n)) 7.
Proof.
intros n H1 H2. (* n : nat
H1 : iguales_nat n 5 = true ->
iguales_nat (S (S n)) 7 = true
H2 : true = iguales_nat n 5
============================
true = iguales_nat (S (S n)) 7 *)
symmetry in H2. (* n : nat
H1 : iguales_nat n 5 = true ->
iguales_nat (S (S n)) 7 = true
H2 : iguales_nat n 5 = true
============================
true = iguales_nat (S (S n)) 7 *)
apply H1 in H2. (* n : nat
H1 : iguales_nat n 5 = true ->
iguales_nat (S (S n)) 7 = true
H2 : iguales_nat (S (S n)) 7 = true
============================
true = iguales_nat (S (S n)) 7 *)
symmetry in H2. (* n : nat
H1 : iguales_nat n 5 = true ->
iguales_nat (S (S n)) 7 = true
H2 : true = iguales_nat (S (S n)) 7
============================
true = iguales_nat (S (S n)) 7 *)
apply H2.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de las tácticas 'apply H1 in H2' y 'symmetry in H'.
------------------------------------------------------------------ *)

(* =====================================================================
§ 5. Control de la hipótesis de inducción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 5.1. Demostrar que
forall n m : nat,
doble n = doble m -> n = m.
------------------------------------------------------------------ *)

(* 1ª intento *)
Theorem doble_inyectiva_fallado : forall n m : nat,
doble n = doble m ->
n = m.
Proof.
intros n m. (* n, m : nat
============================
doble n = doble m -> n = m *)
induction n as [| n' HI].
- (* m : nat
============================
doble 0 = doble m -> 0 = m *)
simpl. (* m : nat
============================
0 = doble m -> 0 = m *)
intros H. (* m : nat
H : 0 = doble m
============================
0 = m *)
destruct m as [| m'].
+ (* H : 0 = doble 0
============================
0 = 0 *)
reflexivity.
+ (* m' : nat
H : 0 = doble (S m')
============================
0 = S m' *)
inversion H.
- (* n', m : nat
HI : doble n' = doble m -> n' = m
============================
doble (S n') = doble m -> S n' = m *)
intros H. (* n', m : nat
HI : doble n' = doble m -> n' = m
H : doble (S n') = doble m
============================
S n' = m *)
destruct m as [| m'].
+ (* n' : nat
HI : doble n' = doble 0 -> n' = 0
H : doble (S n') = doble 0
============================
S n' = 0 *)
simpl in H. (* n' : nat
HI : doble n' = doble 0 -> n' = 0
H : S (S (doble n')) = 0
============================
S n' = 0 *)
inversion H.
+ (* n', m' : nat
HI : doble n' = doble (S m') -> n' = S m'
H : doble (S n') = doble (S m')
============================
S n' = S m' *)
apply funcional. (* n', m' : nat
HI : doble n' = doble (S m') -> n' = S m'
H : doble (S n') = doble (S m')
============================
n' = m' *)
Abort.

(* 2º intento *)
Theorem doble_inyectiva: forall n m,
doble n = doble m ->
n = m.
Proof.
intros n. (* n : nat
============================
forall m : nat, doble n = doble m -> n = m *)
induction n as [| n' HI].
- (*
============================
forall m : nat, doble 0 = doble m -> 0 = m *)
simpl. (* forall m : nat, 0 = doble m -> 0 = m *)
intros m H. (* m : nat
H : 0 = doble m
============================
0 = m *)
destruct m as [| m'].
+ (* H : 0 = doble 0
============================
0 = 0 *)
reflexivity.
+ (* m' : nat
H : 0 = doble (S m')
============================
0 = S m' *)
inversion H.
- (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
============================
forall m : nat, doble (S n') = doble m
-> S n' = m *)
simpl. (* forall m : nat, S (S (doble n')) = doble m
-> S n' = m *)
intros m H. (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
m : nat
H : S (S (doble n')) = doble m
============================
S n' = m *)
destruct m as [| m'].
+ (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
H : S (S (doble n')) = doble 0
============================
S n' = 0 *)
simpl in H. (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
H : S (S (doble n')) = 0
============================
S n' = 0 *)
inversion H.
+ (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
m' : nat
H : S (S (doble n')) = doble (S m')
============================
S n' = S m' *)
apply funcional. (* n' = m' *)
apply HI. (* doble n' = doble m' *)
inversion H. (* n' : nat
HI : forall m : nat, doble n' = doble m -> n' = m
m' : nat
H : S (S (doble n')) = doble (S m')
H1 : doble n' = doble m'
============================
doble n' = doble n' *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la estrategia de generalización.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 5.2. Demostrar que
forall n m : nat,
doble n = doble m ->
n = m.
------------------------------------------------------------------ *)

(* 1º intento *)
Theorem doble_inyectiva_2a: forall n m : nat,
doble n = doble m ->
n = m.
Proof.
intros n m. (* n, m : nat
============================
doble n = doble m -> n = m *)
induction m as [| m' HI].
- (* n : nat
============================
doble n = doble 0 -> n = 0 *)
simpl. (* doble n = 0 -> n = 0 *)
intros H. (* n : nat
H : doble n = 0
============================
n = 0 *)
destruct n as [| n'].
+ (* H : doble 0 = 0
============================
0 = 0 *)
reflexivity.
+ (* n' : nat
H : doble (S n') = 0
============================
S n' = 0 *)
simpl in H. (* n' : nat
H : S (S (doble n')) = 0
============================
S n' = 0 *)
inversion H.
- (* n, m' : nat
HI : doble n = doble m' -> n = m'
============================
doble n = doble (S m') -> n = S m' *)

intros H. (* n, m' : nat
HI : doble n = doble m' -> n = m'
H : doble n = doble (S m')
============================
n = S m' *)
destruct n as [| n'].
+ (* m' : nat
HI : doble 0 = doble m' -> 0 = m'
H : doble 0 = doble (S m')
============================
0 = S m' *)
simpl in H. (* m' : nat
HI : doble 0 = doble m' -> 0 = m'
H : 0 = S (S (doble m'))
============================
0 = S m' *)
inversion H.
+ (* n', m' : nat
HI : doble (S n') = doble m' -> S n' = m'
H : doble (S n') = doble (S m')
============================
S n' = S m' *)
apply funcional. (* n' = m' *)
Abort.

(* 2º intento *)
Theorem doble_inyectiva_2 : forall n m,
doble n = doble m ->
n = m.
Proof.
intros n m. (* n, m : nat
============================
doble n = doble m -> n = m *)
generalize dependent n. (* m : nat
============================
forall n : nat, doble n = doble m -> n = m *)
induction m as [| m' HI].
- (*
============================
forall n : nat, doble n = doble 0 -> n = 0 *)
simpl. (* forall n : nat, doble n = 0 -> n = 0 *)
intros n H. (* n : nat
H : doble n = 0
============================
n = 0 *)
destruct n as [| n'].
+ (* H : doble 0 = 0
============================
0 = 0 *)
reflexivity.
+ (* n' : nat
H : doble (S n') = 0
============================
S n' = 0 *)
simpl in H. (* n' : nat
H : S (S (doble n')) = 0
============================
S n' = 0 *)
inversion H.
- (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
============================
forall n : nat, doble n = doble (S m')
-> n = S m' *)
intros n H. (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
n : nat
H : doble n = doble (S m')
============================
n = S m' *)
destruct n as [| n'].
+ (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
H : doble 0 = doble (S m')
============================
0 = S m' *)
simpl in H. (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
H : 0 = S (S (doble m'))
============================
0 = S m' *)
inversion H.
+ (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
n' : nat
H : doble (S n') = doble (S m')
============================
S n' = S m' *)
apply funcional. (* n' = m' *)
apply HI. (* doble n' = doble m' *)
simpl in H. (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
n' : nat
H : S (S (doble n')) = S (S (doble m'))
============================
doble n' = doble m' *)
inversion H. (* m' : nat
HI : forall n : nat, doble n = doble m' -> n = m'
n' : nat
H : S (S (doble n')) = S (S (doble m'))
H1 : doble n' = doble m'
============================
doble n' = doble n' *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'generalize dependent n'.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 5.3. Demostrar que
forall n m : nat,
iguales_nat n m = true -> n = m.
------------------------------------------------------------------ *)

Theorem iguales_nat_true : forall n m : nat,
iguales_nat n m = true -> n = m.
Proof.
induction n as [|n' HIn'].
- (*
============================
forall m : nat, iguales_nat 0 m = true
-> 0 = m *)
induction m as [|m' HIm'].
+ (*
============================
iguales_nat 0 0 = true -> 0 = 0 *)
reflexivity.
+ (* m' : nat
HIm' : iguales_nat 0 m' = true -> 0 = m'
============================
iguales_nat 0 (S m') = true -> 0 = S m' *)
simpl. (* false = true -> 0 = S m' *)
intros H. (* m' : nat
HIm' : iguales_nat 0 m' = true -> 0 = m'
H : false = true
============================
0 = S m' *)
inversion H.
- (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
============================
forall m : nat, iguales_nat (S n') m = true
-> S n' = m *)
induction m as [|m' HIm'].
+ (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
============================
iguales_nat (S n') 0 = true -> S n' = 0 *)
simpl. (* false = true -> S n' = 0 *)
intros H. (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
H : false = true
============================
S n' = 0 *)
inversion H.
+ (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
m' : nat
HIm' : iguales_nat (S n') m' = true
-> S n' = m'
============================
iguales_nat (S n') (S m') = true
-> S n' = S m' *)
simpl. (* iguales_nat n' m' = true -> S n' = S m' *)
intros H. (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
m' : nat
HIm' : iguales_nat (S n') m' = true
-> S n' = m'
H : iguales_nat n' m' = true
============================
S n' = S m' *)
apply HIn' in H. (* n' : nat
HIn' : forall m:nat, iguales_nat n' m = true
-> n' = m
m' : nat
HIm' : iguales_nat (S n') m' = true
-> S n' = m'
H : n' = m'
============================
S n' = S m' *)
rewrite H. (* S m' = S m' *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 5.3. Demostrar que
forall x y : id,
iguales_id x y = true -> x = y.
------------------------------------------------------------------ *)

Theorem iguales_id_true: forall x y : id,
iguales_id x y = true -> x = y.
Proof.
intros [m] [n]. (* m, n : nat
============================
iguales_id (Id m) (Id n) = true -> Id m = Id n *)
simpl. (* iguales_nat m n = true -> Id m = Id n *)
intros H. (* m, n : nat
H : iguales_nat m n = true
============================
Id m = Id n *)
assert (H' : m = n).
- (* m, n : nat
H : iguales_nat m n = true
============================
m = n *)
apply iguales_nat_true. (* iguales_nat m n = true *)
apply H.
- (* m, n : nat
H : iguales_nat m n = true
H' : m = n
============================
Id m = Id n *)
rewrite H'. (* Id n = Id n *)
reflexivity.
Qed.

(* =====================================================================
§ 6. Expansión de definiciones
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 6.1. Definir la función
cuadrado : nata -> nat
tal que (cuadrado n) es el cuadrado de n.
------------------------------------------------------------------ *)

Definition cuadrado (n:nat) : nat := n * n.

(* ---------------------------------------------------------------------
Ejemplo 6.2. Demostrar que
forall n m : nat,
cuadrado (n * m) = cuadrado n * cuadrado m.
------------------------------------------------------------------ *)

Lemma cuadrado_mult : forall n m : nat,
cuadrado (n * m) = cuadrado n * cuadrado m.
Proof.
intros n m. (* n, m : nat
============================
cuadrado (n * m) =
cuadrado n * cuadrado m *)
unfold cuadrado. (* (n * m) * (n * m) =
(n * n) * (m * m) *)
rewrite producto_asociativa. (* ((n * m) * n) * m =
(n * n) * (m * m) *)
assert (H : (n * m) * n = (n * n) * m).
- (* (n * m) * n = (n * n) * m) *)
rewrite producto_conmutativa. (* n * (n * m) = (n * n) * m *)
apply producto_asociativa.
- (* n, m : nat
H : (n * m) * n = (n * n) * m
============================
((n * m) * n) * m =
(n * n) * (m * m) *)
rewrite H. (* ((n * n) * m) * m =
(n * n) * (m * m) *)
rewrite producto_asociativa. (* ((n * n) * m) * m =
((n * n) * m) * m *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'unfold'
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 6.4. Definir la función
const5 : nat -> nat
tal que (const5 x) es el número 5.
------------------------------------------------------------------ *)

Definition const5 (x: nat) : nat := 5.

(* ---------------------------------------------------------------------
Ejemplo 6.5. Demostrar que
forall m : nat,
const5 m + 1 = const5 (m + 1) + 1.
------------------------------------------------------------------ *)

Fact prop_const5 : forall m : nat,
const5 m + 1 = const5 (m + 1) + 1.
Proof.
intros m. (* m : nat
============================
const5 m + 1 = const5 (m + 1) + 1 *)
simpl. (* 6 = 6 *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Nota. Expansión automática de la definición de const5.
------------------------------------------------------------------ *)

(* ---------------------------------------------------------------------
Ejemplo 6.6. Se coonsidera la siguiente definición
Definition const5b (x:nat) : nat :=
match x with
| O => 5
| S _ => 5
end.

Demostrar que
forall m : nat,
const5b m + 1 = const5b (m + 1) + 1.
------------------------------------------------------------------ *)

Definition const5b (x:nat) : nat :=
match x with
| O => 5
| S _ => 5
end.

(* 1º intento *)
Fact prop_const5b_1: forall m : nat,
const5b m + 1 = const5b (m + 1) + 1.
Proof.
intros m. (* m : nat
============================
const5b m + 1 = const5b (m + 1) + 1 *)
simpl. (* const5b m + 1 = const5b (m + 1) + 1 *)
Abort.

(* 1ª demostración *)
Fact prop_const5b_2: forall m : nat,
const5b m + 1 = const5b (m + 1) + 1.
Proof.
intros m. (* m : nat
============================
const5b m + 1 = const5b (m + 1) + 1 *)
destruct m.
- (*
============================
const5b 0 + 1 = const5b (0 + 1) + 1 *)
simpl. (* 6 = 6 *)
reflexivity.
- (* m : nat
============================
const5b (S m) + 1 = const5b (S m + 1) + 1 *)
simpl. (* 6 = 6 *)
reflexivity.
Qed.

(* 2ª demostración *)
Fact prop_const5b_3: forall m : nat,
const5b m + 1 = const5b (m + 1) + 1.
Proof.
intros m. (* m : nat
============================
const5b m + 1 = const5b (m + 1) + 1 *)
unfold const5b. (* m : nat
============================
match m with
| 0 | _ => 5
end + 1 = match m + 1 with
| 0 | _ => 5
end + 1 *)
destruct m.
- (*
============================
5 + 1 = match 0 + 1 with
| 0 | _ => 5
end + 1 *)
reflexivity.
- (* m : nat
============================
5 + 1 = match S m + 1 with
| 0 | _ => 5
end + 1 *)
reflexivity.
Qed.

(* =====================================================================
§ 7. Uso de 'destruct' sobre expresiones compuestas
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 7.1. Se considera la siguiente definición
Definition const_false (n : nat) : bool :=
if iguales_nat n 3 then false
else if iguales_nat n 5 then false
else false.

Demostrar que
forall n : nat,
const_false n = false.
------------------------------------------------------------------ *)

Definition const_false (n : nat) : bool :=
if iguales_nat n 3 then false
else if iguales_nat n 5 then false
else false.

Theorem const_false_false : forall n : nat,
const_false n = false.
Proof.
intros n. (* n : nat
============================
const_false n = false *)
unfold const_false. (* (if iguales_nat n 3 then false
else if iguales_nat n 5 then false
else false) =
false *)
destruct (iguales_nat n 3).
- (* n : nat
============================
false = false *)
reflexivity.
- (* n : nat
============================
(if iguales_nat n 5 then false
else false) = false *)
destruct (iguales_nat n 5).
+ (* n : nat
============================
false = false *)
reflexivity.
+ (* n : nat
============================
false = false *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 7.2. Se considera la siguiente definición
Definition ej (n : nat) : bool :=
if iguales_nat n 3 then true
else if iguales_nat n 5 then true
else false.

Demostrar que
forall n : nat,
ej n = true -> esImpar n = true.
------------------------------------------------------------------ *)

Definition ej (n : nat) : bool :=
if iguales_nat n 3 then true
else if iguales_nat n 5 then true
else false.

(* 1º intento *)
Theorem ej_impar_a: forall n : nat,
ej n = true ->
esImpar n = true.
Proof.
intros n H. (* n : nat
H : ej n = true
============================
esImpar n = true *)
unfold ej in H. (* n : nat
H : (if iguales_nat n 3
then true
else if iguales_nat n 5
then true
else false)
= true
============================
esImpar n = true *)
destruct (iguales_nat n 3).
- (* n : nat
H : true = true
============================
esImpar n = true *)
Abort.

(* 2º intento *)
Theorem ej_impar : forall n : nat,
ej n = true ->
esImpar n = true.
Proof.
intros n H. (* n : nat
H : ej n = true
============================
esImpar n = true *)
unfold ej in H. (* n : nat
H : (if iguales_nat n 3
then true
else if iguales_nat n 5
then true else false)
= true
============================
esImpar n = true *)
destruct (iguales_nat n 3) eqn: H3.
- (* n : nat
H3 : iguales_nat n 3 = true
H : true = true
============================
esImpar n = true *)
apply iguales_nat_true in H3. (* n : nat
H3 : n = 3
H : true = true
============================
esImpar n = true *)
rewrite H3. (* esImpar 3 = true *)
reflexivity.
- (* n : nat
H3 : iguales_nat n 3 = false
H : (if iguales_nat n 5
then true else false)
= true
============================
esImpar n = true *)
destruct (iguales_nat n 5) eqn:H5.
+ (* n : nat
H3 : iguales_nat n 3 = false
H5 : iguales_nat n 5 = true
H : true = true
============================
esImpar n = true *)
apply iguales_nat_true in H5. (* n : nat
H3 : iguales_nat n 3 = false
H5 : n = 5
H : true = true
============================
esImpar n = true *)
rewrite H5. (* esImpar 5 = true *)
reflexivity.
+ (* n : nat
H3 : iguales_nat n 3 = false
H5 : iguales_nat n 5 = false
H : false = true
============================
esImpar n = true *)
inversion H.
Qed.

(* ---------------------------------------------------------------------
Nota. Uso de la táctica 'destruct e eqn: H'.
------------------------------------------------------------------ *)

(* =====================================================================
§ 8. Resumen de tácticas básicas
================================================================== *)

(* Las tácticas básicas utilizadas hasta ahora son
+ apply H:
+ si el objetivo coincide con la hipótesis H, lo demuestra;
+ si H es una implicación,
+ si el objetivo coincide con la conclusión de H, lo sustituye por
su premisa y
+ si el objetivo coincide con la premisa de H, lo sustituye por
su conclusión.

+ apply ... with ...: Especifica los valores de las variables que no
se pueden deducir por emparejamiento.

+ apply H1 in H2: Aplica la igualdad de la hipótesis H1 a la
hipótesis H2.

+ assert (H: P): Incluye la demostración de la propiedad P y continúa
la demostración añadiendo como premisa la propiedad P con nombre H.

+ destruct b: Distingue dos casos según que b sea True o False.

+ destruct n as [| n1]: Distingue dos casos según que n sea 0 o sea S n1.

+ destruct p as [n m]: Sustituye el par p por (n,m).

+ destruct e eqn: H: Distingue casos según el valor de la expresión
e y lo añade al contexto la hipótesis H.

+ generalize dependent x: Mueve la variable x (y las que dependan de
ella) del contexto a una hipótesis explícita en el objetivo.

+ induction n as [|n1 IHn1]: Inicia una demostración por inducción
sobre n. El caso base en ~n 0~. El paso de la inducción consiste en
suponer la propiedad para ~n1~ y demostrarla para ~S n1~. El nombre de la
hipótesis de inducción es ~IHn1~.

+ intros vars: Introduce las variables del cuantificador universal y,
como premisas, los antecedentes de las implicaciones.

+ inversion: Aplica que los constructores son disjuntos e inyectivos.

+ reflexivity: Demuestra el objetivo si es una igualdad trivial.

+ rewrite H: Sustituye el término izquierdo de H por el derecho.

+ rewrite <-H: Sustituye el término derecho de H por el izquierdo.

+ simpl: Simplifica el objetivo.

+ simpl in H: Simplifica la hipótesis H.

+ symmetry: Cambia un objetivo de la forma s = t en t = s.

+ symmetry in H: Cambia la hipótesis H de la forma ~st~ en ~ts~.

+ unfold f: Expande la definición de la función f.
*)

(* =====================================================================
§ Bibliografía
================================================================== *)

(*
+ "More Basic Tactics" de Peirce et als. http://bit.ly/2LYFTlZ *)
</source>

Tema 4: Polimorfismo y funciones de orden superior en Coq

2019-02-14T07:36:47Z

Jalonso: Protegió «Tema 4: Polimorfismo y funciones de orden superior en Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
Require Export T3_EstructurasNat.

(* El contenido del tema es
1. Polimorfismo
1. Listas polimórficas
1. Inferencia de tipos
2. Síntesis de los tipos de los argumentos
3. Argumentos implícitos
4. Explicitación de argumentos
5. Ejercicios
2. Polimorfismo de pares
3. Resultados opcionales polimórficos
2. Funciones como datos
1. Funciones de orden superior
2. Filtrado
3. Funciones anónimas
4. Aplicación a todos los elementos (map)
5. Plegados (fold)
6. Funciones que construyen funciones
3. Bibliografía
*)

(* =====================================================================
§ 1. Polimorfismo
================================================================== *)

(* =====================================================================
§§ 1.1. Listas polimórficas
================================================================== *)

(* ---------------------------------------------------------------------
Nota. Se suprimen algunos avisos.
------------------------------------------------------------------ *)

Set Warnings "-notation-overridden,-parsing".

(* ---------------------------------------------------------------------
Ejemplo 1.1.1. Definir el tipo (list X) para representar las listas
de elementos de tipo X con los constructores nil y cons tales que
+ nil es la lista vacía y
+ (cons x ys) es la lista obtenida añadiendo el elemento x a la
lista ys.
------------------------------------------------------------------ *)

Inductive list (X : Type) : Type :=
| nil : list X
| cons : X -> list X -> list X.

(* ---------------------------------------------------------------------
Ejemplo 1.1.2. Calcular el tipo de list.
------------------------------------------------------------------ *)

Check list.
(* ===> list : Type -> Type *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.3. Calcular el tipo de (nil nat).
------------------------------------------------------------------ *)

Check (nil nat).
(* ===> nil nat : list nat *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.4. Calcular el tipo de (cons nat 3 (nil nat)).
------------------------------------------------------------------ *)

Check (cons nat 3 (nil nat)).
(* ===> cons nat 3 (nil nat) : list nat *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.5. Calcular el tipo de nil.
------------------------------------------------------------------ *)

Check nil.
(* ===> nil : forall X : Type, list X *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.6. Calcular el tipo de cons.
------------------------------------------------------------------ *)

Check cons.
(* ===> cons : forall X : Type, X -> list X -> list X *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.7. Calcular el tipo de
(cons nat 2 (cons nat 1 (nil nat))).
------------------------------------------------------------------ *)

Check (cons nat 2 (cons nat 1 (nil nat))).
(* ==> cons nat 2 (cons nat 1 (nil nat)) : list nat *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.8. Definir la función
repite (X : Type) (x : X) (n : nat) : list X
tal que (repite X x n) es la lista, de elementos de tipo X, obtenida
repitiendo n veces el elemento x. Por ejemplo,
repite nat 4 2 = cons nat 4 (cons nat 4 (nil nat)).
repite bool false 1 = cons bool false (nil bool).
------------------------------------------------------------------ *)

Fixpoint repite (X : Type) (x : X) (n : nat) : list X :=
match n with
| 0 => nil X
| S n' => cons X x (repite X x n')
end.

Example prop_repite1 :
repite nat 4 2 = cons nat 4 (cons nat 4 (nil nat)).
Proof. reflexivity. Qed.

Example prop_repite2 :
repite bool false 1 = cons bool false (nil bool).
Proof. reflexivity. Qed.

(* =====================================================================
§§§ 1.1.1. Inferencia de tipos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.9. Definir la función
repite' X x n : list X
tal que (repite' X x n) es la lista obtenida repitiendo n veces el
elemento x. Por ejemplo,
repite' nat 4 2 = cons nat 4 (cons nat 4 (nil nat)).
repite' bool false 1 = cons bool false (nil bool).
------------------------------------------------------------------ *)

Fixpoint repite' X x n : list X :=
match n with
| 0 => nil X
| S n' => cons X x (repite' X x n')
end.

(* ---------------------------------------------------------------------
Ejemplo 1.1.10. Calcular los tipos de repite' y repite.
------------------------------------------------------------------ *)

Check repite'.
(* ===> forall X : Type, X -> nat -> list X *)
Check repite.
(* ===> forall X : Type, X -> nat -> list X *)

(* =====================================================================
§§§ 1.1.2. Síntesis de los tipos de los argumentos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.11. Definir la función
repite'' X x n : list X
tal que (repite'' X x n) es la lista obtenida repitiendo n veces el
elemento x, usando argumentos implícitos. Por ejemplo,
repite'' nat 4 2 = cons nat 4 (cons nat 4 (nil nat)).
repite'' bool false 1 = cons bool false (nil bool).
------------------------------------------------------------------ *)

Fixpoint repite'' X x n : list X :=
match n with
| 0 => nil _
| S n' => cons _ x (repite'' _ x n')
end.

(* ---------------------------------------------------------------------
Ejemplo 1.1.12. Definir la lista formada por los números naturales 1,
2 y 3.
------------------------------------------------------------------ *)

Definition list123 :=
cons nat 1 (cons nat 2 (cons nat 3 (nil nat))).

Definition list123' :=
cons _ 1 (cons _ 2 (cons _ 3 (nil _))).

(* =====================================================================
§§§ 1.1.3. Argumentos implícitos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.13. Especificar las siguientes funciones y sus argumentos
explícitos e implícitos:
+ nil
+ constructor
+ repite
------------------------------------------------------------------ *)

Arguments nil {X}.
Arguments cons {X} _ _.
Arguments repite {X} x n.

(* ---------------------------------------------------------------------
Ejemplo 1.1.14. Definir la lista formada por los números naturales 1,
2 y 3.
------------------------------------------------------------------ *)

Definition list123'' := cons 1 (cons 2 (cons 3 nil)).

(* ---------------------------------------------------------------------
Ejemplo 1.1.15. Definir la función
repite''' {X : Type} (x : X) (n : nat) : list X
tal que (repite'' X x n) es la lista obtenida repitiendo n veces el
elemento x, usando argumentos implícitos. Por ejemplo,
repite'' nat 4 2 = cons nat 4 (cons nat 4 (nil nat)).
repite'' bool false 1 = cons bool false (nil bool).
------------------------------------------------------------------ *)

Fixpoint repite''' {X : Type} (x : X) (n : nat) : list X :=
match n with
| 0 => nil
| S n' => cons x (repite''' x n')
end.

Example prop_repite'''1 :
repite''' 4 2 = cons 4 (cons 4 nil).
Proof. reflexivity. Qed.

Example prop_repite'''2 :
repite false 1 = cons false nil.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.1.16. Definir el tipo (list' {X}) para representar las
listas de elementos de tipo X con los constructores nil' y cons'
tales que
+ nil' es la lista vacía y
+ (cons' x ys) es la lista obtenida añadiendo el elemento x a la
lista ys.
------------------------------------------------------------------ *)

Inductive list' {X : Type} : Type :=
| nil' : list'
| cons' : X -> list' -> list'.

(* ---------------------------------------------------------------------
Ejemplo 1.1.17. Definir la función
conc {X : Type} (xs ys : list X) : (list X)
tal que (conc xs ys) es la concatenación de xs e ys.
------------------------------------------------------------------ *)

Fixpoint conc {X : Type} (xs ys : list X) : (list X) :=
match xs with
| nil => ys
| cons x xs' => cons x (conc xs' ys)
end.

(* ---------------------------------------------------------------------
Ejemplo 1.1.18. Definir la función
inversa {X : Type} (xs : list X) : list X
tal que (inversa xs) es la inversa de xs. Por ejemplo,
inversa (cons 1 (cons 2 nil)) = (cons 2 (cons 1 nil)).
inversa (cons true nil) = cons true nil.
------------------------------------------------------------------ *)

Fixpoint inversa {X : Type} (xs : list X) : list X :=
match xs with
| nil => nil
| cons x xs' => conc (inversa xs') (cons x nil)
end.

Example prop_inversa1 :
inversa (cons 1 (cons 2 nil)) = (cons 2 (cons 1 nil)).
Proof. reflexivity. Qed.

Example prop_inversa2:
inversa (cons true nil) = cons true nil.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.1.19. Definir la función
longitud {X : Type} (xs : list X) : nat
tal que (longitud xs) es el número de elementos de xs. Por ejemplo,
longitud (cons 1 (cons 2 (cons 3 nil))) = 3.
------------------------------------------------------------------ *)

Fixpoint longitud {X : Type} (xs : list X) : nat :=
match xs with
| nil => 0
| cons _ xs' => S (longitud xs')
end.

Example prop_longitud1:
longitud (cons 1 (cons 2 (cons 3 nil))) = 3.
Proof. reflexivity. Qed.

(* =====================================================================
§§§ 1.1.4. Explicitación de argumentos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.20. Evaluar la siguiente expresión
Fail Definition n_nil := nil.
------------------------------------------------------------------ *)

Fail Definition n_nil := nil.
(* ==> Error: Cannot infer the implicit parameter X of nil. *)

(* ---------------------------------------------------------------------
Ejemplo 1.1.21. Completar la definición anterior para obtener la
lista vacía de números naturales.
------------------------------------------------------------------ *)

(* 1ª solución *)
Definition n_nil : list nat := nil.

(* 2ª solución *)
Definition n_nil' := @nil nat.

(* ---------------------------------------------------------------------
Ejemplo 1.1.22. Definir las siguientes abreviaturas
+ "x :: y" para (cons x y)
+ "[ ]" para nil
+ "[ x ; .. ; y ]" para (cons x .. (cons y []) ..).
+ "x ++ y" para (conc x y)
------------------------------------------------------------------ *)

Notation "x :: y" := (cons x y)
(at level 60, right associativity).
Notation "[ ]" := nil.
Notation "[ x ; .. ; y ]" := (cons x .. (cons y []) ..).
Notation "x ++ y" := (conc x y)
(at level 60, right associativity).

(* ---------------------------------------------------------------------
Ejemplo 1.1.23. Definir la lista cuyos elementos son 1, 2 y 3.
------------------------------------------------------------------ *)

Definition list123''' := [1; 2; 3].

(* =====================================================================
§§ 1.2. Polimorfismo de pares
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.2.1. Definir el tipo prod (X Y) con el constructor par tal
que (par x y) es el par cuyas componentes son x e y.
------------------------------------------------------------------ *)

Inductive prod (X Y : Type) : Type :=
| par : X -> Y -> prod X Y.

Arguments par {X} {Y} _ _.

(* ---------------------------------------------------------------------
Ejemplo 1.2.2. Definir la abreviaturas
"( x , y )" para (par x y).
------------------------------------------------------------------ *)

Notation "( x , y )" := (par x y).

(* ---------------------------------------------------------------------
Ejemplo 1.2.3. Definir la abreviatura
"X * Y" para (prod X Y)
------------------------------------------------------------------ *)

Notation "X * Y" := (prod X Y) : type_scope.

(* ---------------------------------------------------------------------
Ejemplo 1.2.4. Definir la función
fst {X Y : Type} (p : X * Y) : X
tal que (fst p) es la primera componente del par p. Por ejemplo,
fst (par 3 5) = 3
------------------------------------------------------------------ *)

Definition fst {X Y : Type} (p : X * Y) : X :=
match p with
| (x, y) => x
end.

Example prop_fst: fst (par 3 5) = 3.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.2.5. Definir la función
snd {X Y : Type} (p : X * Y)
tal que (snd p) es la segunda componente del par p. Por ejemplo,
snd (par 3 5) = 5
------------------------------------------------------------------ *)

Definition snd {X Y : Type} (p : X * Y) : Y :=
match p with
| (x, y) => y
end.

Example prop_snd: snd (par 3 5) = 5.
Proof. reflexivity. Qed.

(* =====================================================================
§§ 1.3. Resultados opcionales polimórficos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.3.1. Definir el tipo (Opcional X) con los constructores Some
y None tales que
+ (Some x) es un valor de tipo X.
+ None es el valor nulo.
------------------------------------------------------------------ *)

Inductive Opcional (X:Type) : Type :=
| Some : X -> Opcional X
| None : Opcional X.

Arguments Some {X} _.
Arguments None {X}.

(* =====================================================================
§ 2. Funciones como datos
================================================================== *)

(* =====================================================================
§§ 2.1. Funciones de orden superior
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.1. Definir la función
aplica3veces {X : Type} (f : X -> X) (n : X) : X
tal que (aplica3veces f) aplica 3 veces la función f. Por ejemplo,
aplica3veces menosDos 9 = 3.
aplica3veces negacion true = false.
------------------------------------------------------------------ *)

Definition aplica3veces {X : Type} (f : X -> X) (n : X) : X :=
f (f (f n)).

Check @aplica3veces.
(* ===> aplica3veces : forall X : Type, (X -> X) -> X -> X *)

Example prop_aplica3veces:
aplica3veces menosDos 9 = 3.
Proof. reflexivity. Qed.

Example prop_aplica3veces':
aplica3veces negacion true = false.
Proof. reflexivity. Qed.

(* =====================================================================
§§ 2.2. Filtrado
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.1. Definir la función
filtra {X : Type} (p : X -> bool) (xs : list X) : (list X)
tal que (filtra p xs) es la lista de los elementos de xs que
verifican p. Por ejemplo,
filtra esPar [1;2;3;4] = [2;4].
------------------------------------------------------------------ *)

Fixpoint filtra {X : Type} (p : X -> bool) (xs : list X) : (list X) :=
match xs with
| [] => []
| x :: xs' => if p x
then x :: (filtra p xs')
else filtra p xs'
end.

Example prop_filtra1:
filtra esPar [1;2;3;4] = [2;4].
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.2.2. Definir la función
unitarias {X : Type} (xss : list (list X)) : list (list X) :=
tal que (unitarias xss) es la lista de listas unitarias de xss. Por
ejemplo,
unitarias [[1;2];[3];[4];[5;6;7];[];[8]] = [[3];[4];[8]]
------------------------------------------------------------------ *)

Definition esUnitaria {X : Type} (xs : list X) : bool :=
iguales_nat (longitud xs) 1.

Definition unitarias {X : Type} (xss : list (list X)) : list (list X) :=
filtra esUnitaria xss.

Compute (unitarias [[1; 2]; [3]; [4]; [5;6;7]; []; [8]]).
(* = [[3]; [4]; [8]] : list (list nat)*)

Example prop_unitarias:
unitarias [[1; 2]; [3]; [4]; [5;6;7]; []; [8]]
= [[3]; [4]; [8]].
Proof. reflexivity. Qed.

(* =====================================================================
§§ 2.3. Funciones anónimas
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.3.1. Demostrar que
aplica3veces (fun n => n * n) 2 = 256.
------------------------------------------------------------------ *)

Example prop_anon_fun':
aplica3veces (fun n => n * n) 2 = 256.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.3.2. Calcular
filtra (fun xs => iguales_nat (longitud xs) 1)
[ [1; 2]; [3]; [4]; [5;6;7]; []; [8] ]
------------------------------------------------------------------ *)

Compute (filtra (fun xs => iguales_nat (longitud xs) 1)
[ [1; 2]; [3]; [4]; [5;6;7]; []; [8] ]).
(* = [[3]; [4]; [8]] : list (list nat)*)

(* =====================================================================
§§ 2.4. Aplicación a todos los elementos (map)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.4.1. Definir la función
map {X Y:Type} (f : X -> Y) (xs:list X) : list Y
tal que (map f xs) es la lista obtenida aplicando f a todos los
elementos de xs. Por ejemplo,
map (fun x => plus 3 x) [2;0;2] = [5;3;5].
map esImpar [2;1;2;5] = [false;true;false;true].
map (fun n => [evenb n;esImpar n]) [2;1;2;5]
= [[true;false];[false;true];[true;false];[false;true]].
------------------------------------------------------------------ *)

Fixpoint map {X Y:Type} (f : X -> Y) (xs : list X) : list Y :=
match xs with
| [] => []
| x :: xs' => f x :: map f xs'
end.

Example prop_map1:
map (fun x => plus 3 x) [2;0;2] = [5;3;5].
Proof. reflexivity. Qed.

Example prop_map2:
map esImpar [2;1;2;5] = [false;true;false;true].
Proof. reflexivity. Qed.

Example prop_map3:
map (fun n => [esPar n ; esImpar n]) [2;1;2;5]
= [[true;false];[false;true];[true;false];[false;true]].
Proof. reflexivity. Qed.

(* =====================================================================
§§ 2.5. Plegados (fold)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.5.1. Definir la función
fold {X Y:Type} (f: X -> Y- > Y) (xs : list X) (b : Y) : Y
tal que (fold f xs b) es el plegado de xs con la operación f a partir
del elemento b. Por ejemplo,
fold mult [1;2;3;4] 1 = 24.
fold conjuncion [true;true;false;true] true = false.
fold conc [[1];[];[2;3];[4]] [] = [1;2;3;4].
------------------------------------------------------------------ *)

Fixpoint fold {X Y:Type} (f: X -> Y -> Y) (xs : list X) (b : Y) : Y :=
match xs with
| nil => b
| x :: xs' => f x (fold f xs' b)
end.

Check (fold conjuncion).
(* ===> fold conjuncion : list bool -> bool -> bool *)

Example fold_example1:
fold mult [1;2;3;4] 1 = 24.
Proof. reflexivity. Qed.

Example fold_example2 :
fold conjuncion [true;true;false;true] true = false.
Proof. reflexivity. Qed.

Example fold_example3 :
fold conc [[1];[];[2;3];[4]] [] = [1;2;3;4].
Proof. reflexivity. Qed.

(* =====================================================================
§§ 2.6. Funciones que construyen funciones
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.6.1. Definir la función
constante {X : Type} (x : X) : nat -> X
tal que (constante x) es la función que a todos los naturales le
asigna el x. Por ejemplo,
(constante 5) 99 = 5.
------------------------------------------------------------------ *)

Definition constante {X : Type} (x : X) : nat -> X :=
fun (k : nat) => x.

Example prop_constante:
(constante 5) 99 = 5.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.6.2. Calcular el tipo de plus.
------------------------------------------------------------------ *)

Check plus.
(* ==> nat -> nat -> nat *)

(* ---------------------------------------------------------------------
Ejemplo 2.6.3. Definir la función
plus3 : nat -> nat
tal que (plus3 x) es tres más x. Por ejemplo,
plus3 4 = 7.
aplica3veces plus3 0 = 9.
aplica3veces (plus 3) 0 = 9.
------------------------------------------------------------------ *)

Definition plus3 := plus 3.

Example prop_plus3a:
plus3 4 = 7.
Proof. reflexivity. Qed.

Example prop_plus3b:
aplica3veces plus3 0 = 9.
Proof. reflexivity. Qed.

Example prop_plus3c:
aplica3veces (plus 3) 0 = 9.
Proof. reflexivity. Qed.

(* =====================================================================
§ Bibliografía
================================================================== *)

(*
+ "Polymorphism and higher-order functions" de Peirce et als.
http://bit.ly/2Mj5gMf *)
</source>

Tema 3: Datos estructurados en Coq

2019-02-14T07:36:22Z

Jalonso: Protegió «Tema 3: Datos estructurados en Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
Require Export T2_Induccion.

(* En este capítulos se estudian datos estructurados con números
naturales. Su contenido es
1. Pares de números
2. Listas de números
1. El tipo de la lista de números.
2. La función repite (repeat)
3. La función longitud (length)
4. La función conc (app)
5. Las funciones primero (hd) y resto (tl)
6. Ejercicios sobre listas de números
7. Multiconjuntos como listas
3. Razonamiento sobre listas
1. Demostraciones por simplificación
2. Demostraciones por casos
3. Demostraciones por inducción
4. Ejercicios
4. Opcionales
5. Diccionarios (o funciones parciales)
6. Bibliografía
*)

(* =====================================================================
§ 1. Pares de números
================================================================== *)

(* ---------------------------------------------------------------------
Nota. Se inicia el módulo ListaNat.
------------------------------------------------------------------ *)

Module ListaNat.

(* ---------------------------------------------------------------------
Ejemplo 1.1. Definir el tipo ProdNat para los pares de números
naturales con el constructor
par : nat -> nat -> ProdNat.
------------------------------------------------------------------ *)

Inductive ProdNat : Type :=
par : nat -> nat -> ProdNat.

(* ---------------------------------------------------------------------
Ejemplo 1.2. Calcular el tipo de la expresión (par 3 5)
------------------------------------------------------------------ *)

Check (par 3 5).
(* ===> par 3 5 : ProdNat *)

(* ---------------------------------------------------------------------
Ejemplo 1.3. Definir la función
fst : ProdNat -> nat
tal que (fst p) es la primera componente de p.
------------------------------------------------------------------ *)

Definition fst (p : ProdNat) : nat :=
match p with
| par x y => x
end.

(* ---------------------------------------------------------------------
Ejemplo 1.4. Evaluar la expresión
fst (par 3 5)
------------------------------------------------------------------ *)

Compute (fst (par 3 5)).
(* ===> 3 : nat *)

(* ---------------------------------------------------------------------
Ejemplo 1.5. Definir la función
snd : ProdNat -> nat
tal que (snd p) es la segunda componente de p.
------------------------------------------------------------------ *)

Definition snd (p : ProdNat) : nat :=
match p with
| par x y => y
end.

(* ---------------------------------------------------------------------
Ejemplo 1.6. Definir la notación (x,y) como una abreviaura de
(par x y).
------------------------------------------------------------------ *)

Notation "( x , y )" := (par x y).

(* ---------------------------------------------------------------------
Ejemplo 1.7. Evaluar la expresión
fst (3,5)
------------------------------------------------------------------ *)

Compute (fst (3,5)).
(* ===> 3 : nat *)

(* ---------------------------------------------------------------------
Ejemplo 1.8. Redefinir la función fst usando la abreviatura de pares.
------------------------------------------------------------------ *)

Definition fst' (p : ProdNat) : nat :=
match p with
| (x,y) => x
end.

(* ---------------------------------------------------------------------
Ejemplo 1.9. Redefinir la función snd usando la abreviatura de pares.
------------------------------------------------------------------ *)

Definition snd' (p : ProdNat) : nat :=
match p with
| (x,y) => y
end.

(* ---------------------------------------------------------------------
Ejemplo 1.10. Definir la función
intercambia : ProdNat -> ProdNat
tal que (intercambia p) es el par obtenido intercambiando las
componentes de p.
------------------------------------------------------------------ *)

Definition intercambia (p : ProdNat) : ProdNat :=
match p with
| (x,y) => (y,x)
end.

(* ---------------------------------------------------------------------
Ejemplo 1.11. Demostrar que para todos los naturales
(n,m) = (fst (n,m), snd (n,m)).
------------------------------------------------------------------ *)

Theorem par_componentes1 : forall n m : nat,
(n,m) = (fst (n,m), snd (n,m)).
Proof.
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.12. Demostrar que para todo par de naturales
p = (fst p, snd p).
------------------------------------------------------------------ *)

(* 1º intento *)
Theorem par_componentes2 : forall p : ProdNat,
p = (fst p, snd p).
Proof.
simpl. (*
============================
forall p : ProdNat, p = (fst p, snd p) *)
Abort.

(* 2º intento *)
Theorem par_componentes : forall p : ProdNat,
p = (fst p, snd p).
Proof.
intros p. (* p : ProdNat
============================
p = (fst p, snd p) *)
destruct p as [n m]. (* n, m : nat
============================
(n, m) = (fst (n, m), snd (n, m)) *)
simpl. (* (n, m) = (n, m) *)
reflexivity.
Qed.

(* =====================================================================
§ 2. Listas de números
================================================================== *)

(* =====================================================================
§§ 2.1. El tipo de la lista de números.
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1.1. Definir el tipo ListaNat de la lista de los números
naturales y cuyo constructores son
+ nil (la lista vacía) y
+ cons (tal que (cons x ys) es la lista obtenida añadiéndole x a ys).
------------------------------------------------------------------ *)

Inductive ListaNat : Type :=
| nil : ListaNat
| cons : nat -> ListaNat -> ListaNat.

(* ---------------------------------------------------------------------
Ejemplo 2.1.2. Definir la constante
ejLista : ListaNat
que es la lista cuyos elementos son 1, 2 y 3.
------------------------------------------------------------------ *)

Definition ejLista := cons 1 (cons 2 (cons 3 nil)).

(* ---------------------------------------------------------------------
Ejemplo 2.1.3. Definir la notación (x :: ys) como una abreviatura de
(cons x ys).
------------------------------------------------------------------ *)

Notation "x :: l" := (cons x l)
(at level 60, right associativity).

(* ---------------------------------------------------------------------
Ejemplo 2.1.4. Definir la notación de las listas finitas escribiendo
sus elementos entre corchetes y separados por puntos y comas.
------------------------------------------------------------------ *)

Notation "[ ]" := nil.
Notation "[ x ; .. ; y ]" := (cons x .. (cons y nil) ..).

(* ---------------------------------------------------------------------
Ejemplo 2.1.5. Definir la lista cuyos elementos son 1, 2 y 3 mediante
sistintas representaciones.
------------------------------------------------------------------ *)

Definition ejLista1 := 1 :: (2 :: (3 :: nil)).
Definition ejLista2 := 1 :: 2 :: 3 :: nil.
Definition ejLista3 := [1;2;3].

(* =====================================================================
§§ 2.2. La función repite (repeat)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.2.1. Definir la función
repite : nat -> nat -> ListaNat
tal que (repite n k) es la lista formada por k veces el número n. Por
ejemplo,
repite 5 3 = [5; 5; 5]

Nota: La función repite es quivalente a la predefinida repeat.
------------------------------------------------------------------ *)

Fixpoint repite (n k : nat) : ListaNat :=
match k with
| O => nil
| S k' => n :: repite n k'
end.

Compute (repite 5 3).
(* ===> [5; 5; 5] : ListaNat*)

(* =====================================================================
§§ 2.3. La función longitud (length)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.3.1. Definir la función
longitud : ListaNat -> nat
tal que (longitud xs) es el número de elementos de xs. Por ejemplo,
longitud [4;2;6] = 3

Nota: La función longitud es equivalente a la predefinida length
------------------------------------------------------------------ *)

Fixpoint longitud (xs : ListaNat) : nat :=
match xs with
| nil => O
| _ :: xs => S (longitud xs)
end.

Compute (longitud [4;2;6]).
(* ===> 3 : nat *)

(* =====================================================================
§§ 2.4. La función conc (app)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.4.1. Definir la función
conc : ListaNat -> ListaNat -> ListaNat
tal que (conc xs ys) es la concatenación de xs e ys. Por ejemplo,
conc [1;3] [4;2;3;5] = [1; 3; 4; 2; 3; 5]

Nota: La función conc es equivalente a la predefinida app.
------------------------------------------------------------------ *)

Fixpoint conc (xs ys : ListaNat) : ListaNat :=
match xs with
| nil => ys
| x :: zs => x :: conc zs ys
end.

Compute (conc [1;3] [4;2;3;5]).
(* ===> [1; 3; 4; 2; 3; 5] : ListaNat *)

(* ---------------------------------------------------------------------
Ejemplo 2.4.2. Definir la notación (xs ++ ys) como una abreviaura de
(conc xs ys).
------------------------------------------------------------------ *)

Notation "x ++ y" := (conc x y)
(right associativity, at level 60).

(* ---------------------------------------------------------------------
Ejemplo 2.4.3. Demostrar que
[1;2;3] ++ [4;5] = [1;2;3;4;5].
nil ++ [4;5] = [4;5].
[1;2;3] ++ nil = [1;2;3].
------------------------------------------------------------------ *)

Example test_conc1: [1;2;3] ++ [4;5] = [1;2;3;4;5].
Proof. reflexivity. Qed.

Example test_conc2: nil ++ [4;5] = [4;5].
Proof. reflexivity. Qed.

Example test_conc3: [1;2;3] ++ nil = [1;2;3].
Proof. reflexivity. Qed.

(* =====================================================================
§§ 2.5. Las funciones primero (hd) y resto (tl)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.5.1. Definir la función
primero : nat -> ListaNat -> ListaNat
tal que (primero d xs) es el primer elemento de xs o d, si xs es la lista
vacía. Por ejemplo,
primero 7 [3;2;5] = 3
primero 7 [] = 7

Nota. La función primero es equivalente a la predefinida hd
------------------------------------------------------------------ *)

Definition primero (d : nat) (xs : ListaNat) : nat :=
match xs with
| nil => d
| y :: ys => y
end.

Compute (primero 7 [3;2;5]).
(* ===> 3 : nat *)
Compute (primero 7 []).
(* ===> 7 : nat *)

(* ---------------------------------------------------------------------
Ejemplo 2.5.2. Demostrar que
primero 0 [1;2;3] = 1.
resto [1;2;3] = [2;3].
------------------------------------------------------------------ *)

Example prop_primero1: primero 0 [1;2;3] = 1.
Proof. reflexivity. Qed.

Example prop_primero2: primero 0 [] = 0.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 2.5.3. Definir la función
resto : ListaNat -> ListaNat
tal que (resto xs) es el resto de xs. Por ejemplo.
resto [3;2;5] = [2; 5]
resto [] = [ ]

Nota. La función resto es equivalente la predefinida tl.
------------------------------------------------------------------ *)

Definition resto (xs:ListaNat) : ListaNat :=
match xs with
| nil => nil
| y :: ys => ys
end.

Compute (resto [3;2;5]).
(* ===> [2; 5] : ListaNat *)
Compute (resto []).
(* ===> [ ] : ListaNat *)

(* ---------------------------------------------------------------------
Ejemplo 2.5.4. Demostrar que
resto [1;2;3] = [2;3].
------------------------------------------------------------------ *)

Example prop_resto: resto [1;2;3] = [2;3].
Proof. reflexivity. Qed.

(* =====================================================================
§ 3. Razonamiento sobre listas
================================================================== *)

(* =====================================================================
§§ 3.1. Demostraciones por simplificación
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 3.1.1. Demostrar que, para toda lista de naturales xs,
[] ++ xs = xs
------------------------------------------------------------------ *)

Theorem nil_conc : forall xs:ListaNat,
[] ++ xs = xs.
Proof.
reflexivity.
Qed.

(* =====================================================================
§§ 3.2. Demostraciones por casos
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 3.2.1. Demostrar que, para toda lista de naturales xs,
pred (longitud xs) = longitud (resto xs)
------------------------------------------------------------------ *)

Theorem resto_longitud_pred : forall xs : ListaNat,
pred (longitud xs) = longitud (resto xs).
Proof.
intros xs. (* xs : ListaNat
============================
Nat.pred (longitud xs) = longitud (resto xs) *)
destruct xs as [|x xs'].
- (*
============================
Nat.pred (longitud []) = longitud (resto []) *)
reflexivity.
- (* x : nat
xs' : ListaNat
============================
Nat.pred (longitud (x :: xs')) =
longitud (resto (x :: xs')) *)
reflexivity.
Qed.

(* =====================================================================
§§ 3.3. Demostraciones por inducción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 3.3.1. Demostrar que la concatenación de listas de naturales
es asociativa; es decir,
(xs ++ ys) ++ zs = xs ++ (ys ++ zs).
------------------------------------------------------------------ *)

Theorem conc_asociativa: forall xs ys zs : ListaNat,
(xs ++ ys) ++ zs = xs ++ (ys ++ zs).
Proof.
intros xs ys zs. (* xs, ys, zs : ListaNat
============================
(xs ++ ys) ++ zs = xs ++ (ys ++ zs) *)
induction xs as [|x xs' HI].
- (* ys, zs : ListaNat
============================
([ ] ++ ys) ++ zs = [ ] ++ (ys ++ zs) *)
reflexivity.
- (* x : nat
xs', ys, zs : ListaNat
HI : (xs' ++ ys) ++ zs = xs' ++ (ys ++ zs)
============================
((x :: xs') ++ ys) ++ zs =
(x :: xs') ++ (ys ++ zs) *)
simpl. (* (x :: (xs' ++ ys)) ++ zs =
x :: (xs' ++ (ys ++ zs)) *)
rewrite -> HI. (* x :: (xs' ++ (ys ++ zs)) =
x :: (xs' ++ (ys ++ zs)) *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.3.2. Definir la función
inversa : ListaNat -> ListaNat
tal que (inversa xs) es la inversa de xs. Por ejemplo,
inversa [1;2;3] = [3;2;1].
inversa nil = nil.

Nota. La función inversa es equivalente a la predefinida rev.
------------------------------------------------------------------ *)

Fixpoint inversa (xs:ListaNat) : ListaNat :=
match xs with
| nil => nil
| x::xs' => inversa xs' ++ [x]
end.

Example prop_inversa1:
inversa [1;2;3] = [3;2;1].
Proof. reflexivity. Qed.

Example prop_inversa2:
inversa nil = nil.
Proof. reflexivity. Qed.

(* ---------------------------------------------------------------------
Ejemplo 3.3.3. Demostrar que
longitud (inversa xs) = longitud xs
------------------------------------------------------------------ *)

(* 1º intento *)
Theorem longitud_inversa1: forall xs : ListaNat,
longitud (inversa xs) = longitud xs.
Proof.
intros xs.
induction xs as [|x xs' HI].
- (*
============================
longitud (inversa [ ]) = longitud [ ] *)
reflexivity.
- (* x : nat
xs' : ListaNat
HI : longitud (inversa xs') = longitud xs'
============================
longitud (inversa (x :: xs')) =
longitud (x :: xs') *)
simpl. (* longitud (inversa xs' ++ [x]) =
S (longitud xs')*)
rewrite <- HI. (* longitud (inversa xs' ++ [x]) =
S (longitud (inversa xs')) *)
Abort.

(* Nota: Para simplificar la última expresión se necesita los siguientes
lemas. *)

Lemma longitud_conc : forall xs ys : ListaNat,
longitud (xs ++ ys) = longitud xs + longitud ys.
Proof.
intros xs ys. (* xs, ys : ListaNat
============================
longitud (xs ++ ys) =
longitud xs + longitud ys *)
induction xs as [| x xs' HI].
- (* ys : ListaNat
============================
longitud ([ ] ++ ys) =
longitud [ ] + longitud ys *)
reflexivity.
- (* x : nat
xs', ys : ListaNat
HI : longitud (xs' ++ ys) =
longitud xs' + longitud ys
============================
longitud ((x :: xs') ++ ys) =
longitud (x :: xs') + longitud ys *)
simpl. (* S (longitud (xs' ++ ys)) =
S (longitud xs' + longitud ys) *)
rewrite HI. (* S (longitud xs' + longitud ys) =
S (longitud xs' + longitud ys) *)
reflexivity.
Qed.

Theorem suma_n_1 : forall n : nat,
n + 1 = S n.
Proof.
intro n. (* n : nat
============================
n + 1 = S n *)
induction n as [|n' HIn'].
- (*
============================
0 + 1 = 1 *)
reflexivity.
- (* n' : nat
HIn' : n' + 1 = S n'
============================
S n' + 1 = S (S n') *)
simpl. (* S (n' + 1) = S (S n') *)
rewrite HIn'. (* S (S n') = S (S n') *)
reflexivity.
Qed.

(* 2º intento *)

Theorem longitud_inversa : forall xs:ListaNat,
longitud (inversa xs) = longitud xs.
Proof.
intros xs. (* xs : ListaNat
============================
longitud (inversa xs) = longitud xs *)
induction xs as [| x xs' HI].
- (*
============================
longitud (inversa [ ]) = longitud [ ] *)
reflexivity.
- (* x : nat
xs' : ListaNat
HI : longitud (inversa xs') = longitud xs'
============================
longitud (inversa (x :: xs')) =
longitud (x :: xs') *)
simpl. (* longitud (inversa xs' ++ [x]) =
S (longitud xs') *)
rewrite longitud_conc. (* longitud (inversa xs') + longitud [x] =
S (longitud xs') *)
rewrite HI. (* longitud xs' + longitud [x] =
S (longitud xs') *)
simpl. (* longitud xs' + 1 = S (longitud xs') *)
rewrite suma_n_1. (* 1 + longitud xs' = S (longitud xs') *)
reflexivity.
Qed.

(* =====================================================================
§ 4. Opcionales
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 4.1. Definir el tipo OpcionalNat con los contructores
Some : nat -> OpcionalNat
None : OpcionalNat.
------------------------------------------------------------------ *)

Inductive OpcionalNat : Type :=
| Some : nat -> OpcionalNat
| None : OpcionalNat.

(* ---------------------------------------------------------------------
Ejemplo 4.2. Definir la función
nthOpcional : ListaNat -> nat -> OpcionalNat
tal que (nthOpcional xs n) es el n-ésimo elemento de la lista xs o None
si la lista tiene menos de n elementos. Por ejemplo,
nthOpcional [4;5;6;7] 0 = Some 4.
nthOpcional [4;5;6;7] 3 = Some 7.
nthOpcional [4;5;6;7] 9 = None.
------------------------------------------------------------------ *)

Fixpoint nthOpcional (xs : ListaNat) (n : nat) : OpcionalNat :=
match xs with
| nil => None
| x :: xs' => match iguales_nat n O with
| true => Some x
| false => nthOpcional xs' (pred n)
end
end.

Example prop_nthOpcional1 :
nthOpcional [4;5;6;7] 0 = Some 4.
Proof. reflexivity. Qed.

Example prop_nthOpcional2 :
nthOpcional [4;5;6;7] 3 = Some 7.
Proof. reflexivity. Qed.

Example prop_nthOpcional3 :
nthOpcional [4;5;6;7] 9 = None.
Proof. reflexivity. Qed.

(* La definición con condicionales es: *)
Fixpoint nthOpcional' (xs : ListaNat) (n : nat) : OpcionalNat :=
match xs with
| nil => None
| x :: xs' => if iguales_nat x O
then Some x
else nthOpcional' xs' (pred n)
end.

(* ---------------------------------------------------------------------
Ejemplo 4.3. Definir la función
extraeOpcionalNat -> OpcionalNat -> nat
tal que (extraeOpcionalNat d o) es el valor de o, si o tiene valor o es d
en caso contrario. Por ejemplo,
extraeOpcionalNat 3 (Some 7) = 7
extraeOpcionalNat 3 None = 3
------------------------------------------------------------------ *)

Definition extraeOpcionalNat (d : nat) (o : OpcionalNat) : nat :=
match o with
| Some n' => n'
| None => d
end.

Compute (extraeOpcionalNat 3 (Some 7)).
(* ===> 7 : nat *)
Compute (extraeOpcionalNat 3 None).
(* ===> 3 : nat *)

(* ---------------------------------------------------------------------
Nota. Finalizar el módulo ListaNat.
------------------------------------------------------------------ *)

End ListaNat.

(* =====================================================================
§ 5. Diccionarios (o funciones parciales)
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 5.1. Definir el tipo id (por identificador) con el
constructor
Id : nat -> id.
------------------------------------------------------------------ *)

Inductive id : Type :=
| Id : nat -> id.

(* ---------------------------------------------------------------------
Ejemplo 5.2. Definir la función
iguales_id : id -> id -> bool
tal que (iguales_id x1 x2) se verifica si tienen la misma clave. Por
ejemplo,
iguales_id (Id 3) (Id 3) = true : bool
iguales_id (Id 3) (Id 4) = false : bool
------------------------------------------------------------------ *)

Definition iguales_id (x1 x2 : id) :=
match x1, x2 with
| Id n1, Id n2 => iguales_nat n1 n2
end.

Compute (iguales_id (Id 3) (Id 3)).
(* ===> true : bool *)
Compute (iguales_id (Id 3) (Id 4)).
(* ===> false : bool *)

(* ---------------------------------------------------------------------
Ejemplo 5.3. Iniciar el módulo Diccionario que importa a ListaNat.
------------------------------------------------------------------ *)

Module Diccionario.
Export ListaNat.

(* ---------------------------------------------------------------------
Ejemplo 5.4. Definir el tipo diccionario con los contructores
vacio : diccionario
registro : id -> nat -> diccionario -> diccionario.
------------------------------------------------------------------ *)

Inductive diccionario : Type :=
| vacio : diccionario
| registro : id -> nat -> diccionario -> diccionario.

(* ---------------------------------------------------------------------
Ejemplo 5.5. Definir los diccionarios cuyos elementos son
+ []
+ [(3,6)]
+ [(2,4), (3,6)]
------------------------------------------------------------------ *)

Definition diccionario1 := vacio.
Definition diccionario2 := registro (Id 3) 6 diccionario1.
Definition diccionario3 := registro (Id 2) 4 diccionario2.

(* ---------------------------------------------------------------------
Ejemplo 5.6. Definir la función
valor : id -> diccionario -> OpcionalNat
tal que (valor i d) es el valor de la entrada de d con clave i, o
None si d no tiene ninguna entrada con clave i. Por ejemplo,
valor (Id 2) diccionario3 = Some 4
valor (Id 2) diccionario2 = None
------------------------------------------------------------------ *)

Fixpoint valor (x : id) (d : diccionario) : OpcionalNat :=
match d with
| vacio => None
| registro y v d' => if iguales_id x y
then Some v
else valor x d'
end.

Compute (valor (Id 2) diccionario3).
(* = Some 4 : OpcionalNat *)
Compute (valor (Id 2) diccionario2).
(* = None : OpcionalNat*)

(* ---------------------------------------------------------------------
Ejemplo 5.7. Definir la función
actualiza : diccionario -> id -> nat -> diccionario
tal que (actualiza d x v) es el diccionario obtenido a partir del d
+ si d tiene un elemento con clave x, le cambia su valor a v
+ en caso contrario, le añade el elemento v con clave x
------------------------------------------------------------------ *)

Definition actualiza (d : diccionario)
(x : id) (v : nat)
: diccionario :=
registro x v d.

(* ---------------------------------------------------------------------
Ejemplo 5.8. Finalizar el módulo Diccionario
------------------------------------------------------------------ *)

End Diccionario.

(* =====================================================================
§ Bibliografía
================================================================== *)

(*
+ "Working with structured data" de Peirce et als.
http://bit.ly/2LQABsv
*)
</source>

Tema 2: Demostraciones por inducción sobre los números naturales en Coq

2019-02-14T07:36:02Z

Jalonso: Protegió «Tema 2: Demostraciones por inducción sobre los números naturales en Coq» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang="coq">
Require Export T1_PF_en_Coq.

(* El contenido de la teoría es
1. Demostraciones por inducción.
2. Demostraciones anidadas.
3. Demostraciones formales vs demostraciones informales.
4. Ejercicios complementarios *)

(* =====================================================================
§ 1. Demostraciones por inducción
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 1.1. Demostrar que
forall n:nat, n = n + 0.
------------------------------------------------------------------ *)

(* 1º intento: con métodos elementales *)
Theorem suma_n_0_a: forall n : nat, n = n + 0.
Proof.
intros n. (* n : nat
============================
n = n + 0 *)
simpl. (* n : nat
============================
n = n + 0 *)
Abort.

(* 2º intento: con casos *)
Theorem suma_n_0_b : forall n : nat,
n = n + 0.
Proof.
intros n. (* n : nat
============================
n = n + 0 *)
destruct n as [| n'].
- (*
============================
0 = 0 + 0 *)
reflexivity.
- (* n' : nat
============================
S n' = S n' + 0 *)
simpl. (* n' : nat
============================
S n' = S (n' + 0) *)
Abort.

(* 3ª intento: con inducción *)
Theorem suma_n_0 : forall n : nat,
n = n + 0.
Proof.
intros n. (* n : nat
============================
n = n + 0 *)
induction n as [| n' IHn'].
+ (*
============================
0 = 0 + 0 *)
reflexivity.
+ (* n' : nat
IHn' : n' = n' + 0
============================
S n' = S n' + 0 *)
simpl. (* S n' = S (n' + 0) *)
rewrite <- IHn'. (* S n' = S n' *)
reflexivity.
Qed.

(* ---------------------------------------------------------------------
Ejemplo 1.2. Demostrar que
forall n, n - n = 0.
------------------------------------------------------------------ *)

Theorem resta_n_n: forall n : nat, n - n = 0.
Proof.
intros n. (* n : nat
============================
n - n = 0 *)
induction n as [| n' IHn'].
+ (*
============================
0 - 0 = 0 *)
reflexivity.
+ (* n' : nat
IHn' : n' - n' = 0
============================
S n' - S n' = 0 *)
simpl. (* n' - n' = 0 *)
rewrite IHn'. (* 0 = 0 *)
reflexivity.
Qed.

(* =====================================================================
§ 2. Demostraciones anidadas
================================================================== *)

(* ---------------------------------------------------------------------
Ejemplo 2.1. Demostrar que
forall n m : nat, (0 + n) * m = n * m.
------------------------------------------------------------------ *)

Theorem producto_0_suma': forall n m : nat, (0 + n) * m = n * m.
Proof.
intros n m. (* n, m : nat
============================
(0 + n) * m = n * m *)
assert (H: 0 + n = n).
- (* n, m : nat
============================
0 + n = n *)
reflexivity.
- (* n, m : nat
H : 0 + n = n
============================
(0 + n) * m = n * m *)
rewrite -> H. (* n * m = n * m *)
reflexivity.
Qed.

(* =====================================================================
§ Bibliografía
================================================================== *)

(*
+ "Demostraciones por inducción" de Peirce et als. http://bit.ly/2NRSWTF
*)
</source>

Temas

2019-02-14T07:35:46Z

Jalonso: Protegió «Temas» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

En esta página se irán publicando los temas conforme se vayan estudiando.

== RA con Isabelle/HOL ==
* [[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: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-1.pdf Tema 7a: Sintaxis y semántica de la lógica proposicional].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7b: Deducción natural proposicional].
** [[Tema 7b: Deducción natural proposicional con Isabelle/HOL | Tema 7c: Deducción natural proposicional con Isabelle/HOL]].
* Tema 8: Deducción natural de primer orden:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-7.pdf Tema 8a: Sintaxis y semántica de la lógica de primer orden].
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-8.pdf Tema 8b: Deducción natural en lógica de primer orden].
** [[Tema 8b: Deducción natural en lógica de primer orden con Isabelle/HOL | Tema 8c: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 9: Editores lógicos]].
* [[Tema 10: Caso de estudio: Compilación de expresiones]].
* [[Tema 11: Definiciones inductivas]].
* [[Tema 12: Conjuntos, funciones y relaciones]].

== RA con Coq ==
* [[Tema 1: Programación funcional y métodos elementales de demostración en Coq]].
* [[Tema 2: Demostraciones por inducción sobre los números naturales en Coq]].
* [[Tema 3: Datos estructurados en Coq]].
* [[Tema 4: Polimorfismo y funciones de orden superior en Coq]].
* [[Tema 5: Tácticas básicas de Coq]].