Razonamiento automático (2014-15) - Contribuciones del usuario [es]

Documentación

2022-02-08T17:21:44Z

Jalonso:

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

== Visiones generales de la DAO ==

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

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

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

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

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

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

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

Documentación

2022-02-08T10:59:35Z

Jalonso:

Documentación

2015-02-04T05:50:00Z

Jalonso: /* Otros cursos */

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

== Visiones generales de la DAO ==

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

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/prog-prove.pdf Programming and proving in Isabelle/HOL]. 5 de diciembre de 2013.
# T. Nipkow, M. Wenzel y L.C. Paulson [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/tutorial.pdf A proof assistant for higher-order logic]. Springer-Verlag. 5 de diciembre de 2013.
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/library/HOL/HOL/document.pdf Isabelle/HOL — Higher-Order Logic]. 5 de diciembre de 2013.
# M. Wenzel [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/isar-ref.pdf The Isabelle/Isar Reference Manual]. 5 de diciembre de 2013.
# M. Wenzel [https://www.lri.fr/~wenzel/Isabelle2011-Paris/quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle2013].

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

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

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# A.D. Brucker, D. Basin, J.G. Smaus y B. Wolff. [http://archiv.infsec.ethz.ch/education/permanent/csmr.html Computer-supported Modeling and Reasoning]. (ETH Zurich, 2011).
# Mads Dam. [http://www.csc.kth.se/utbildning/kth/kurser/DD2453/aform07/ Advanced formal methods]. (KTH Royal Institute of Technology, 2007).
# Jacques Fleuriot y Paul Jackson. [http://www.inf.ed.ac.uk/teaching/courses/ar/slides/ Automated reasoning]. (Univ. de Edimburgo, 2012-13).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www4.informatik.tu-muenchen.de/~nipkow/semantics/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/Homepage/SVHOL10 Specification and Verification with Higher-Order Logic].
# Viorel Preoteasa, Ralph-Johan Back y Charmi Panchal. [http://users.abo.fi/vpreotea/isabelle-2012 Introduction to mechanized reasoning with Isabelle/HOL]. (Åbo Akademi University, 2012).
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# Yves Bertot, Pierre Casteran, Benjamin Gregoire, Pierre Letouzey y Assia Mahboubi [http://www.di.ens.fr/~zappa/teaching/coq/ecole11 Modelling and verifying algorithms in Coq: an introduction]. (INRIA Paris-Rocquencourt, 14-18 noviembre 2011).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Nuno Gaspar [http://www-sop.inria.fr/members/Nuno.Gaspar/teaching/coq2012.php Verification with the Coq Proof Assistant] (INRIA Sophia Antipolis, 2012-13).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# Michael Genesereth [http://logic.stanford.edu/classes/cs157/2011/cs157.html Computational Logic] (Univ. de Stanford, 2011-12).
# Ian Hodkinson [http://www.doc.ic.ac.uk/~imh/teaching/140_logic/logic.html Logic] (Imperial College, Londres, 2010-11).
# Peter Lucas [http://www.cs.ru.nl/~peterl/teaching/KeR/ Knowledge Representation and Reasoning] (Radboud University # egen, 2011-12).
# Larry Paulson [http://www.cl.cam.ac.uk/Teaching/current/LogicProof/ Logic and Proof] (Univ. de Cambridge, 2011-12).
# David Pichardie [http://www.irisa.fr/celtique/pichardie/teaching/M2/MDV/ Méthode de vérification] (Universidad de Rennes, 2006-07).
# Michael Winter [Logic in Computer Science] (Brock University, Ontario, Canada, 2010-11).

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

== Artículos recientes ==
Están en orden cronológico inverso a la fecha de su reseña en [http://www.glc.us.es/~jalonso/vestigium/tag/resena Vestigium]:
# [http://bit.ly/1iZjgqN Proof Pearl: A probabilistic proof for the Girth-Chromatic number theorem]. L. Noschinski
# [http://bit.ly/1iJ8uVz A graph library for Isabelle]. ~ L. Noschinski
# [http://bit.ly/I0CU80 Gödel’s incompleteness theorems]. ~ L.C. Paulson
# [http://bit.ly/I0CPRN The hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/HBiIJI Applications of real number theorem proving in PVS]. ~ H. Gottliebsen, R. Hardy, O. Lightfoot y U. Martin
# [http://bit.ly/1awnMLB A machine-assisted proof of Gödel’s incompleteness theorems for the theory of hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/19lWeYy Verified AIG algorithms in ACL2]. ~ J. Davis y S. Swords
# [http://bit.ly/GAhC00 A formal model and correctness proof for an access control policy framework]. ~ C. Wu, X. Zhang y C. Urban
# [http://bit.ly/16SMvSS The ontological argument in PVS]. ~ J. Rushby
# [http://bit.ly/1dRt9n0 Formalizing Moessner’s theorem and generalizations in Nuprl]. ~ M. Bickford, D. Kozen y A. Silva
# [http://bit.ly/1bSeDNB Formalization in PVS of balancing properties necessary for the security of the Dolev-Yao cascade protocol model]. ~ M. Ayala y Y. Santos
# [http://bit.ly/1feFqWE Proof assistant based on didactic considerations]. ~ J. Pais y A Tasistro
# [http://bit.ly/18tHNBi Theory exploration for interactive theorem proving]. ~ M. Johansson
# [http://bit.ly/1b0242s From Tarski to Hilbert]. ~ G. Braun y J. Narboux
# [http://bit.ly/18HaXaR Formal verification of language-based concurrent noninterference]. ~ A. Popescu, J. Hölzl y T. Nipkow
# [http://bit.ly/1aRTQsU A Traffic Alert and Collision Avoidance System(TCAS-II) Resolution Advisory Algorithm]. ~ C. Muñoz, A. Narkawicz y J. Chamberlain
# [http://bit.ly/1dNwhDI Formal verification of cryptographic security proofs]. ~ M. Berg
# [http://bit.ly/17muAUv Polygonal numbers in Mizar]. ~ A. Grabowski
# [http://bit.ly/1hk5z6L A mechanised proof of Gödel’s incompleteness theorems using Nominal Isabelle]. ~ L.C. Paulson
# [http://bit.ly/1cSL0wE Steps towards verified implementations of HOL Light]. ~ M.O. Myreen, S. Owens y R. Kumar
# [http://bit.ly/16Kbgm0 Generic datatypes à la carte]. ~ S. Keuchel y T. Schrijvers
# [http://bit.ly/1bqJGx4 Proof pearl: A verified bignum implementation in x86-64 machine code]. ~ M.O. Myreen y G. Curello
# [http://bit.ly/142ow2Q Mechanized metatheory for a λ λ-calculus with trust types]. ~ R. Ribeiro, C. Camarão y L. Figueiredo
# [http://bit.ly/15WZBDy Proving soundness of combinatorial Vickrey auctions and generating verified executable code]. ~ M.B. Caminati, M. Kerber, C. Lange y C. Rowat
# [http://bit.ly/198g4n9 A computer-assisted proof of correctness of a marching cubes algorithm]. ~ A.N. Chernikov y J. Xu
# [http://bit.ly/11QA5g7 Verifying the bridge between simplicial topology and algebra: the Eilenberg-Zilber algorithm]. ~ L. Lambán, J. Rubio, F.J. Martín y J.L. Ruiz
# [http://bit.ly/1cJAXYk The Königsberg bridge problem and the friendship theorem]. ~ W. Li
# [http://bit.ly/13DBK9R Formal verification of a proof procedure for the description logic ALC]. ~ M. Chaabani, M. Mezghiche y M. Strecker
# [http://bit.ly/1ep2ex9 Pratt’s primality certificates]. ~ S. Wimmer y L. Noschinski
# [http://bit.ly/13C95Ci Reasoning about higher-order relational specifications]. ~ Y. Wang, K. Chaudhuri, A. Gacek y G. Nadathur
# [http://bit.ly/18QQLcL Proofs you can believe in – Proving equivalences between Prolog semantics in Coq]. ~ J. Kriener, A. King y S. Blazy
# [http://bit.ly/19uc82J Certified, efficient and sharp univariate Taylor models in Coq]. ~ E. Martin-Dorel, L. Rideau, L. Théry, M. Mayero y I. Paşca
# [http://bit.ly/1c4Rzel Ordinals in HOL: Transfinite arithmetic up to (and beyond) ω₁]. ~ M. Norrish y B. Huffman
# [http://bit.ly/14b4Akz Program verification based on Kleene algebra in Isabelle/HOL] ~ A. Armstrong, G. Struth y T. Weber
# [http://bit.ly/1aOgRKx Reading an algebra textbook (by translating it to a formal document in the Isabelle/Isar language)]. ~ C. Ballarin
# [http://bit.ly/11HKixj Computational verification of network programs in Coq]. ~ G. Stewart
# [http://www.glc.us.es/~jalonso/vestigium/resena-certifying-homological-algorithms-to-study-biomedical-images Certifying homological algorithms to study biomedical images]. ~ M. Poza
# [http://bit.ly/16Nks9m Formalizing cut elimination of coalgebraic logics in Coq]. ~ H. Tews
# [http://www.glc.us.es/~jalonso/vestigium/resena-the-formalization-of-syntax-based-mathematical-algorithms-using-quotation-and-evaluation/ The formalization of syntax-based mathematical algorithms using quotation and evaluation]. ~ W.M. Farmer
# [http://www.glc.us.es/~jalonso/vestigium/resena-certified-symbolic-manipulation-bivariate-simplicial-polynomials/ Certified symbolic manipulation: Bivariate simplicial polynomials]. ~ L. Lambán, F.J. Martín, J. Rubio y J.L. Ruiz
# [http://www.glc.us.es/~jalonso/vestigium/resena-solveurs-cpfd-verifies-formellement/ Solveurs CP(FD) vérifiés formellement]. ~ C Dubois y A. Gotlieb
# [http://www.glc.us.es/~jalonso/vestigium/resena-formalizing-bounded-increase/ Formalizing bounded increase]. ~ R. Thiemann
# [http://www.glc.us.es/~jalonso/vestigium/resena-formal-mathematics-on-display-a-wiki-for-flyspeck/ Formal mathematics on display: A wiki for Flyspeck]. ~ C. Tankink, C. Kaliszyk, J. Urban y H. Geuvers
# [http://www.glc.us.es/~jalonso/vestigium/resena-theorem-of-three-circles-in-coq Theorem of three circles in Coq]. ~ J. Zsidó
# [http://bit.ly/19fiWAY Certified HLints with Isabelle/HOLCF-Prelude]. ~ J. Breitner, B. Huffman, N. Mitchell y C. Sternagel
# [http://bit.ly/ZfSQrQ Automatic data refinement]. ~ P. Lammich
# [http://bit.ly/18vyjm7 The rooster and the butterflies (a machine-checked proof of the Jordan-Hölder theorem for finite groups)]. ~ A. Mahboubi
# [http://bit.ly/114oyZV Mechanical verification of SAT refutations with extended resolution]. ~ N. Wetzler, M.J.H. Heule y W.A. Hunt Jr.
# [http://bit.ly/13H0REu Type classes and filters for mathematical analysis in Isabelle/HOL] ~ J. Hölzl, F. Immler y B. Huffman
# [http://bit.ly/10fv8wO Verifying refutations with extended resolution]. ~ M. J. H. Heule, W. A. Hunt, Jr. y N. Wetzler
# [http://bit.ly/10EcFWj A Web interface for Isabelle: The next generation]. ~ C. Lüth y M. Ring
# [http://bit.ly/18P9CSv On the formalization of continuous-time Markov chains in HOL]. ~ L. Liu, O. Hasan y S. Tahar
# [http://bit.ly/17H2mqy Formalizing Turing machines]. ~ A. Asperti y W. Ricciotti
# [http://bit.ly/YwuCeL Light-weight containers for Isabelle: efficient, extensible, nestable]. ~ A. Lochbihler
# [http://bit.ly/10XLrRA Graph theory]. ~ L. Noschinski
# [http://bit.ly/19kPEP4 A machine-checked proof of the odd order theorem]. ~ G. Gonthier et als.
# [http://goo.gl/LdihL A constructive theory of regular languages in Coq]. ~ C. Doczkal, J.O. Kaiser y G. Smolka
# [http://goo.gl/gwcwL A formal proof of Kruskal’s tree theorem in Isabelle/HOL]. ~ C. Sternagel
# [http://goo.gl/CUF3e Formalizing Knuth-Bendix orders and Knuth-Bendix completion]. ~ C. Sternagel y R. Thiemann
# [http://goo.gl/9JAfX Developing an auction theory toolbox]. ~ C. Lange, C. Rowat, W. Windsteiger y M. Kerber
# [http://goo.gl/6OfmQ Formalization of incremental simplex algorithm by stepwise refinement]. ~ M. Spasić y F. Marić
# [http://goo.gl/Guxky Coinductive pearl: Modular first-order logic completeness]. ~ J.C. Blanchette, A. Popescu y D. Traytel
# [http://goo.gl/HUOl8 A fully verified executable LTL model checker]. ~ J. Esparza et als.
# [http://goo.gl/RV54S ForMaRE - formal mathematical reasoning in economics]. ~ M. Kerber, C. Lange y C. Rowat.
# [http://goo.gl/Y7sIq AI over large formal knowledge bases: The first decade]. ~ J. Urban.
# [http://goo.gl/vvqNg Formalization of real analysis: A survey of proof assistants and libraries]. ~ S. Boldo, C. Lelay y G. Melquiond.
# [http://goo.gl/bEFYa Data refinement in Isabelle/HOL]. ~ F. Haftmann, A. Krauss, O. Kunčar y T. Nipkow
# [http://goo.gl/xTyvE Formalizing the confluence of orthogonal rewriting systems]. ~ A.C. Rocha y M. Ayala.
# [http://goo.gl/zCYHj Formalization of the complex number theory in HOL4]. ~ Z. Shi et als.
# [http://goo.gl/kM0dI Programming and reasonning with PowerLists in Coq]. ~ F. Loulergue y V. Niculescu
# [http://goo.gl/KkU6s A hierarchy of mathematical structures in ACL2]. ~ J. Heras, F.J. Martín y V. Pascual.
# [http://www.inf.kcl.ac.uk/staff/urbanc/Publications/tm.pdf Mechanising Turing Machines and Computability Theory in Isabelle/HOL] ~ J. Xu, X. Zhang y C. Urban

Tema 12e: Sudoku

2015-01-29T12:14:36Z

<source lang="isar">
(* Title: HOL/ex/Sudoku.thy
Author: Tjark Weber
Copyright 2005-2014
*)

header {* A SAT-based Sudoku Solver *}

theory T12e_Sudoku
imports Main
begin

text {*
See the paper "A SAT-based Sudoku Solver" (Tjark Weber, published at
LPAR'05) for further explanations. (The paper describes an older
version of this theory that used the model finder refute to find
Sudoku solutions. The refute tool has since been superseded by
nitpick, which is used below.)
*}

no_notation Groups.one_class.one ("1")

datatype digit = A ("1") | B ("2") | C ("3") | D ("4") | E ("5") |
F ("6") | G ("7") | H ("8") | I ("9")

definition valid :: "digit => digit => digit => digit => digit =>
digit => digit => digit => digit => bool" where
"valid x1 x2 x3 x4 x5 x6 x7 x8 x9 ≡
(x1≠x2)∧(x1≠x3)∧(x1≠x4)∧(x1≠x5)∧(x1≠x6)∧(x1≠x7)∧(x1≠x8)∧(x1≠x9)
∧(x2≠x3)∧(x2≠x4)∧(x2≠x5)∧(x2≠x6)∧(x2≠x7)∧(x2≠x8)∧(x2≠x9)
∧(x3≠x4)∧(x3≠x5)∧(x3≠x6)∧(x3≠x7)∧(x3≠x8)∧(x3≠x9)
∧(x4≠x5)∧(x4≠x6)∧(x4≠x7)∧(x4≠x8)∧(x4≠x9)
∧(x5≠x6)∧(x5≠x7)∧(x5≠x8)∧(x5≠x9)
∧(x6≠x7)∧(x6≠x8)∧(x6≠x9)
∧(x7≠x8)∧(x7≠x9)
∧(x8≠x9)"

definition sudoku ::
"digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
digit => digit => digit => digit => digit => digit => digit => digit => digit =>
bool" where
"sudoku x11 x12 x13 x14 x15 x16 x17 x18 x19
x21 x22 x23 x24 x25 x26 x27 x28 x29
x31 x32 x33 x34 x35 x36 x37 x38 x39
x41 x42 x43 x44 x45 x46 x47 x48 x49
x51 x52 x53 x54 x55 x56 x57 x58 x59
x61 x62 x63 x64 x65 x66 x67 x68 x69
x71 x72 x73 x74 x75 x76 x77 x78 x79
x81 x82 x83 x84 x85 x86 x87 x88 x89
x91 x92 x93 x94 x95 x96 x97 x98 x99 ≡

valid x11 x12 x13 x14 x15 x16 x17 x18 x19
∧ valid x21 x22 x23 x24 x25 x26 x27 x28 x29
∧ valid x31 x32 x33 x34 x35 x36 x37 x38 x39
∧ valid x41 x42 x43 x44 x45 x46 x47 x48 x49
∧ valid x51 x52 x53 x54 x55 x56 x57 x58 x59
∧ valid x61 x62 x63 x64 x65 x66 x67 x68 x69
∧ valid x71 x72 x73 x74 x75 x76 x77 x78 x79
∧ valid x81 x82 x83 x84 x85 x86 x87 x88 x89
∧ valid x91 x92 x93 x94 x95 x96 x97 x98 x99

∧ valid x11 x21 x31 x41 x51 x61 x71 x81 x91
∧ valid x12 x22 x32 x42 x52 x62 x72 x82 x92
∧ valid x13 x23 x33 x43 x53 x63 x73 x83 x93
∧ valid x14 x24 x34 x44 x54 x64 x74 x84 x94
∧ valid x15 x25 x35 x45 x55 x65 x75 x85 x95
∧ valid x16 x26 x36 x46 x56 x66 x76 x86 x96
∧ valid x17 x27 x37 x47 x57 x67 x77 x87 x97
∧ valid x18 x28 x38 x48 x58 x68 x78 x88 x98
∧ valid x19 x29 x39 x49 x59 x69 x79 x89 x99

∧ valid x11 x12 x13 x21 x22 x23 x31 x32 x33
∧ valid x14 x15 x16 x24 x25 x26 x34 x35 x36
∧ valid x17 x18 x19 x27 x28 x29 x37 x38 x39
∧ valid x41 x42 x43 x51 x52 x53 x61 x62 x63
∧ valid x44 x45 x46 x54 x55 x56 x64 x65 x66
∧ valid x47 x48 x49 x57 x58 x59 x67 x68 x69
∧ valid x71 x72 x73 x81 x82 x83 x91 x92 x93
∧ valid x74 x75 x76 x84 x85 x86 x94 x95 x96
∧ valid x77 x78 x79 x87 x88 x89 x97 x98 x99"

text {*
Just an arbitrary Sudoku grid:
*}

theorem "¬ sudoku
x11 x12 x13 x14 x15 x16 x17 x18 x19
x21 x22 x23 x24 x25 x26 x27 x28 x29
x31 x32 x33 x34 x35 x36 x37 x38 x39
x41 x42 x43 x44 x45 x46 x47 x48 x49
x51 x52 x53 x54 x55 x56 x57 x58 x59
x61 x62 x63 x64 x65 x66 x67 x68 x69
x71 x72 x73 x74 x75 x76 x77 x78 x79
x81 x82 x83 x84 x85 x86 x87 x88 x89
x91 x92 x93 x94 x95 x96 x97 x98 x99"
nitpick [expect=genuine]
oops

text {*
An ``easy'' Sudoku:
*}

theorem "¬ sudoku
5 3 x13 x14 7 x16 x17 x18 x19
6 x22 x23 1 9 5 x27 x28 x29
x31 9 8 x34 x35 x36 x37 6 x39
8 x42 x43 x44 6 x46 x47 x48 3
4 x52 x53 8 x55 3 x57 x58 1
7 x62 x63 x64 2 x66 x67 x68 6
x71 6 x73 x74 x75 x76 2 8 x79
x81 x82 x83 4 1 9 x87 x88 5
x91 x92 x93 x94 8 x96 x97 7 9 "
nitpick [expect=genuine]
oops

text {*
A ``hard'' Sudoku:
*}

theorem "¬ sudoku
x11 2 x13 x14 x15 x16 x17 x18 x19
x21 x22 x23 6 x25 x26 x27 x28 3
x31 7 4 x34 8 x36 x37 x38 x39
x41 x42 x43 x44 x45 3 x47 x48 2
x51 8 x53 x54 4 x56 x57 1 x59
6 x62 x63 5 x65 x66 x67 x68 x69
x71 x72 x73 x74 1 x76 7 8 x79
5 x82 x83 x84 x85 9 x87 x88 x89
x91 x92 x93 x94 x95 x96 x97 4 x99"
nitpick [expect=genuine]
oops

text {*
Some ``exceptionally difficult'' Sudokus, taken from
@{url "http://en.wikipedia.org/w/index.php?title=Algorithmics_of_sudoku&oldid=254685903"}
(accessed December~2, 2008).
*}

text {*
\begin{verbatim}
Rating Program: gsf's sudoku q1 (rating)
Rating: 99408
Poster: JPF
Label: Easter Monster
1.......2.9.4...5...6...7...5.9.3.......7.......85..4.7.....6...3...9.8...2.....1
1 . . | . . . | . . 2
. 9 . | 4 . . | . 5 .
. . 6 | . . . | 7 . .
------+-------+------
. 5 . | 9 . 3 | . . .
. . . | . 7 . | . . .
. . . | 8 5 . | . 4 .
------+-------+------
7 . . | . . . | 6 . .
. 3 . | . . 9 | . 8 .
. . 2 | . . . | . . 1
\end{verbatim}
*}

theorem "¬ sudoku
1 x12 x13 x14 x15 x16 x17 x18 2
x21 9 x23 4 x25 x26 x27 5 x29
x31 x32 6 x34 x35 x36 7 x38 x39
x41 5 x43 9 x45 3 x47 x48 x49
x51 x52 x53 x54 7 x56 x57 x58 x59
x61 x62 x63 8 5 x66 x67 4 x69
7 x72 x73 x74 x75 x76 6 x78 x79
x81 3 x83 x84 x85 9 x87 8 x89
x91 x92 2 x94 x95 x96 x97 x98 1 "
nitpick [expect=genuine]
oops

text {*
\begin{verbatim}
Rating Program: gsf's sudoku q1 (Processing time)
Rating: 4m19s@2 GHz
Poster: tarek
Label: tarek071223170000-052
..1..4.......6.3.5...9.....8.....7.3.......285...7.6..3...8...6..92......4...1...
. . 1 | . . 4 | . . .
. . . | . 6 . | 3 . 5
. . . | 9 . . | . . .
------+-------+------
8 . . | . . . | 7 . 3
. . . | . . . | . 2 8
5 . . | . 7 . | 6 . .
------+-------+------
3 . . | . 8 . | . . 6
. . 9 | 2 . . | . . .
. 4 . | . . 1 | . . .
\end{verbatim}
*}

theorem "¬ sudoku
x11 x12 1 x14 x15 4 x17 x18 x19
x21 x22 x23 x24 6 x26 3 x28 5
x31 x32 x33 9 x35 x36 x37 x38 x39
8 x42 x43 x44 x45 x46 7 x48 3
x51 x52 x53 x54 x55 x56 x57 2 8
5 x62 x63 x64 7 x66 6 x68 x69
3 x72 x73 x74 8 x76 x77 x78 6
x81 x82 9 2 x85 x86 x87 x88 x89
x91 4 x93 x94 x95 1 x97 x98 x99"
nitpick [expect=genuine]
oops

text {*
\begin{verbatim}
Rating Program: Nicolas Juillerat's Sudoku explainer 1.2.1
Rating: 11.9
Poster: tarek
Label: golden nugget
.......39.....1..5..3.5.8....8.9...6.7...2...1..4.......9.8..5..2....6..4..7.....
. . . | . . . | . 3 9
. . . | . . 1 | . . 5
. . 3 | . 5 . | 8 . .
------+-------+------
. . 8 | . 9 . | . . 6
. 7 . | . . 2 | . . .
1 . . | 4 . . | . . .
------+-------+------
. . 9 | . 8 . | . 5 .
. 2 . | . . . | 6 . .
4 . . | 7 . . | . . .
\end{verbatim}
*}

theorem "¬ sudoku
x11 x12 x13 x14 x15 x16 x17 3 9
x21 x22 x23 x24 x25 1 x27 x28 5
x31 x32 3 x34 5 x36 8 x38 x39
x41 x42 8 x44 9 x46 x47 x48 6
x51 7 x53 x54 x55 2 x57 x58 x59
1 x62 x63 4 x65 x66 x67 x68 x69
x71 x72 9 x74 8 x76 x77 5 x79
x81 2 x83 x84 x85 x86 6 x88 x89
4 x92 x93 7 x95 x96 x97 x98 x99"
nitpick [expect=genuine]
oops

text {*
\begin{verbatim}
Rating Program: dukuso's suexrat9
Rating: 4483
Poster: coloin
Label: col-02-08-071
.2.4.37.........32........4.4.2...7.8...5.........1...5.....9...3.9....7..1..86..
. 2 . | 4 . 3 | 7 . .
. . . | . . . | . 3 2
. . . | . . . | . . 4
------+-------+------
. 4 . | 2 . . | . 7 .
8 . . | . 5 . | . . .
. . . | . . 1 | . . .
------+-------+------
5 . . | . . . | 9 . .
. 3 . | 9 . . | . . 7
. . 1 | . . 8 | 6 . .
\end{verbatim}
*}

theorem "¬ sudoku
x11 2 x13 4 x15 3 7 x18 x19
x21 x22 x23 x24 x25 x26 x27 3 2
x31 x32 x33 x34 x35 x36 x37 x38 4
x41 4 x43 2 x45 x46 x47 7 x49
8 x52 x53 x54 5 x56 x57 x58 x59
x61 x62 x63 x64 x65 1 x67 x68 x69
5 x72 x73 x74 x75 x76 9 x78 x79
x81 3 x83 9 x85 x86 x87 x88 7
x91 x92 1 x94 x95 8 6 x98 x99"
nitpick [expect=genuine]
oops

text {*
\begin{verbatim}
Rating Program: dukuso's suexratt (10000 2 option)
Rating: 2141
Poster: tarek
Label: golden nugget
.......39.....1..5..3.5.8....8.9...6.7...2...1..4.......9.8..5..2....6..4..7.....
. . . | . . . | . 3 9
. . . | . . 1 | . . 5
. . 3 | . 5 . | 8 . .
------+-------+------
. . 8 | . 9 . | . . 6
. 7 . | . . 2 | . . .
1 . . | 4 . . | . . .
------+-------+------
. . 9 | . 8 . | . 5 .
. 2 . | . . . | 6 . .
4 . . | 7 . . | . . .
\end{verbatim}
*}

theorem "¬ sudoku
x11 x12 x13 x14 x15 x16 x17 3 9
x21 x22 x23 x24 x25 1 x27 x28 5
x31 x32 3 x34 5 x36 8 x38 x39
x41 x42 8 x44 9 x46 x47 x48 6
x51 7 x53 x54 x55 2 x57 x58 x59
1 x62 x63 4 x65 x66 x67 x68 x69
x71 x72 9 x74 8 x76 x77 5 x79
x81 2 x83 x84 x85 x86 6 x88 x89
4 x92 x93 7 x95 x96 x97 x98 x99"
nitpick [expect=genuine]
oops

end
</source>

Tema 12d: Pasos elementales

2015-01-29T12:13:52Z

Jalonso: Página creada con '<source lang="isar"> header {* T12d: Pasos elementales *} theory T12d_Pasos_elementales imports Main begin text {* "thm" escribe el enunciado de los teoremas cuyos nombres se ...'

<source lang="isar">
header {* T12d: Pasos elementales *}

theory T12d_Pasos_elementales
imports Main
begin

text {* "thm" escribe el enunciado de los teoremas cuyos nombres se
indican. *}
thm conjI impI iffI notI

text{* Instanciación de teoremas con "of": *}
thm conjI
thm conjI[of "A" "B"]
thm conjI[of "A"]
thm conjI[of _ "B"]

text{* Instanciación de teoremas con "where": *}
thm conjI
thm conjI [where ?Q = "B"]

text {* Composición de teoremas con "OF": *}
thm refl
thm refl [of "a"]
thm conjI
thm conjI [OF refl [of "a"] refl [of "b"]]
thm conjI [OF refl [of "a"]]
thm conjI [OF _ refl [of "b"]]

text {* Una demostración por razonamiento hacia atrás: *}
lemma "⟦ A; B ⟧ ⟹ A ∧ B"
apply (rule conjI)
apply assumption
apply assumption
done

text {* Indicación de regla de introducción a "blast": *}

thm le_trans

lemma "⟦ (a::nat) ≤ b; b ≤ c; c ≤ d ⟧ ⟹ a ≤ d"
by (blast intro: le_trans)

end
</source>

Tema 12c: Automatización

2015-01-29T12:13:02Z

Jalonso: Página creada con '<source lang="isar"> header {* T12c: Automatización *} theory T12c_Automatizacion imports Main begin section {* Lógica y conjuntos *} subsection {* Demostraciones con auto ...'

<source lang="isar">
header {* T12c: Automatización *}

theory T12c_Automatizacion
imports Main
begin

section {* Lógica y conjuntos *}

subsection {* Demostraciones con auto *}

lemma "∀x. ∃y. x=y"
by auto

lemma "A ⊆ B ∩ C ⟹ A ⊆ B ∪ C"
by auto

subsection {* Demostraciones con fastforce *}

lemma "⟦ ∀xs ∈ A. ∃ys. xs = ys @ ys; us:A ⟧ ⟹ ∃n. length us = n+n"
by fastforce

text {* Nota: Obsérvese la notación de los cuantificadores acotados: *}

text {* Nota: Con auto no se puede probar el lema anterior. *}

subsection {* Demostraciones con blast *}

text {*
Nota: Muchas propiedades de la LPO y de la teoría de conjuntos se
pueden demostrar automáticamente.

Prop.: Si T es total, A es antisimétrica y T es un subconjunto de A,
entonces A es un subconjunto de T.
*}

lemma AT:
"⟦ ∀x y. T x y ∨ T y x;
∀x y. A x y ∧ A y x ⟶ x = y;
∀x y. T x y ⟶ A x y ⟧
⟹ ∀x y. A x y ⟶ T x y"
by blast

text {* Nota: Con auto no se puede probar el lema anterior. *}

section{* Sledgehammer *}

lemma "⟦xs @ ys = ys @ xs; length xs = length ys⟧ ⟹ xs = ys"
by (metis append_eq_conv_conj)

lemma "R^* ⊆ (R ∪ S)^*"
by (metis Un_upper1 rtrancl_mono)

lemma "a # xs = ys @ [a] ⟹ P"
oops

lemma "xs @ ys = ys @ xs ⟹ P"
oops

section {* Aritmética *}

lemma "⟦ (a::nat) ≤ x + b; 2*x < c ⟧ ⟹ 2*a+1 ≤ 2*b+c"
by arith

end
</source>

Tema 12b: Razonamiento modular

2015-01-29T12:12:10Z

Jalonso: Página creada con '<source lang="isar"> header {* T12b: Razonamiento modular mediante entornos locales *} theory T12b_Razonamiento_modular imports Main begin text {* Basado en http://www.cs...'

<source lang="isar">
header {* T12b: Razonamiento modular mediante entornos locales *}

theory T12b_Razonamiento_modular
imports Main
begin

text {*
Basado en
http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04/slides/Demo14.thy
*}

section {* Ejemplo 1 *}

locale semi =
fixes prod :: "['a, 'a] => 'a" (infixl "⋅" 70)
assumes assoc: "(x ⋅ y) ⋅ z = x ⋅ (y ⋅ z)"

locale group = semi +
fixes one ("𝟭") and inv ("_⇧-" [100] 100)
assumes l_one: "𝟭 ⋅ x = x"
assumes l_inv: "x⇧-⋅ x = 𝟭"

lemma (in group) r_inv:
"x ⋅ x⇧- = 𝟭"
proof -
have "x ⋅ x⇧- = 𝟭 ⋅ (x ⋅ x⇧-)" by (simp only: l_one)
also have "… = (𝟭 ⋅ x) ⋅ x⇧-" by (simp only: assoc)
also have "… = (((x⇧-)⇧- ⋅ x⇧-) ⋅ x) ⋅ x⇧-" by (simp only: l_inv)
also have "… = ((x⇧-)⇧- ⋅ (x⇧- ⋅ x)) ⋅ x⇧-" by (simp only: assoc)
also have "… = ((x⇧-)⇧- ⋅ 𝟭) ⋅ x⇧-" by (simp only: l_inv)
also have "… = (x⇧-)⇧- ⋅ (𝟭 ⋅ x⇧-)" by (simp only: assoc)
also have "… = (x⇧-)⇧- ⋅ x⇧-" by (simp only: l_one)
also have "… = 𝟭" by (simp only: l_inv)
finally show ?thesis .
qed

lemma (in group) r_one:
"x ⋅ 𝟭 = x"
proof -
have "x ⋅ 𝟭 = x ⋅ (x⇧- ⋅ x)" by (simp only: l_inv)
also have "… = (x ⋅ x⇧-) ⋅ x" by (simp only: assoc)
also have "… = 𝟭 ⋅ x" by (simp only: r_inv)
also have "… = x" by (simp only: l_one)
finally show "x ⋅ 𝟭 = x" .
qed

lemma (in group) l_cancel [simp]:
"(x ⋅ y = x ⋅ z) = (y = z)"
proof
assume "x ⋅ y = x ⋅ z"
then have "(x⇧- ⋅ x) ⋅ y = (x⇧- ⋅ x) ⋅ z" by (simp add: assoc)
then show "y = z" by (simp add: l_inv l_one)
next
assume "y = z"
then show "x ⋅ y = x ⋅ z" by simp
qed

subsection {* Exportación *}

thm semi.assoc group.l_cancel

subsection {* Definiciones *}

locale semi2 = semi +
fixes rprod (infixl "⊙" 70)
defines rprod_def: "rprod x y ≡ y ⋅ x "

lemma (in semi2) r_assoc:
"(x ⊙ y) ⊙ z = x ⊙ (y ⊙ z)"
by (simp only: rprod_def assoc)

thm semi2.r_assoc

end
</source>

Tema 12a: Razonamiento modular (Teoría de grupos)

2015-01-29T12:11:13Z

Jalonso: Página creada con '<source lang="isar"> header {* T12a: Razonamiento modular. La teoría de grupos *} theory T12a_Razonamiento_modular_Teoria_de_grupos imports Main begin text {* El objetivo d...'

<source lang="isar">
header {* T12a: Razonamiento modular. La teoría de grupos *}

theory T12a_Razonamiento_modular_Teoria_de_grupos
imports Main
begin

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

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

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

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

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

context grupo
begin

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

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

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

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

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

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

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

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

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

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

-- "La demostración automática es (obtenida con Sledgehammer) es"
lemma unicidad_neutro_i:
assumes "e ⋅ x = x"
shows "𝟭 = e"
using assms
by (metis asociativa inverso_i neutro_i)

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

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

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

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

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

-- "La demostración automática es (obtenida con Sledgehammer) es"
lemma inversa_producto:
"(x ⋅ y)^ = y^ ⋅ x^"
by (metis asociativa inverso_i neutro_i)

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

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

-- "La demostración automática es (obtenida con Sledgehammer) es"
lemma inverso_inverso:
"(x^)^ = x"
by (metis inverso_d unicidad_inverso_i)

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

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

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

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

end

end
</source>

Tema 11: Gramáticas libre de contexto

2015-01-29T12:10:21Z

Jalonso: Página creada con '<source lang="isar"> header {* T11: Gramáticas libres de contexto *} theory T11_Gramaticas_libre_de_contexto imports Main begin text {* En esta relación se definen dos gra...'

<source lang="isar">
header {* T11: Gramáticas libres de contexto *}

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

lemma T_en_S:
assumes "w ∈ T"
shows "w ∈ S"
using assms
proof (induct rule: T.induct)
show "[] ∈ S" by (rule S1)
next
fix v w
assume "v ∈ T" and "v ∈ S" and "w ∈ T" and "w ∈ S"
have "[A] @ w @ [B] ∈ S" using `w ∈ S` by (rule S2)
with `v ∈ S` show "v @ [A] @ w @ [B] ∈ S" by (rule S3)
qed

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

text {*
Se usarán dos lemas auxiliares:
· S_en_T_aux1: w ∈ T ⟹ [A] @ w @ [B] ∈ T
· S_en_T_aux2: v ∈ T ⟹ u ∈ T ⟹ u @ v ∈ T
*}

-- "La demostración estructurada del primer lema es"
lemma S_en_T_aux1:
assumes "w ∈ T"
shows "[A] @ w @ [B] ∈ T"
proof -
have "[] ∈ T" by (rule T1)
hence "[] @ [A] @ w @ [B] ∈ T" using assms by (rule T2)
thus "[A] @ w @ [B] ∈ T" by simp
qed

-- "La demostración automática del primer lema es"
lemma S_en_T_aux1b:
"w ∈ T ⟹ [A] @ w @ [B] ∈ T"
using T1 T2 [where v = "[]"] by simp

-- "La demostración estructurada del segundo lema es"
lemma S_en_T_aux2:
"v ∈ T ⟹ u ∈ T ⟹ u @ v ∈ T"
proof (induct rule: T.induct)
assume "u ∈ T"
thus "u @ [] ∈ T" by simp
next
fix w1 w2
assume "w1 ∈ T"
"u ∈ T ⟹ u @ w1 ∈ T"
"w2 ∈ T"
"u ∈ T ⟹ u @ w2 ∈ T"
"u ∈ T"
hence "u @ w1 ∈ T" by simp
hence "(u @ w1) @ [A] @ w2 @ [B] ∈ T" using `w2 ∈ T` by (rule T2)
thus "u @ w1 @ [A] @ w2 @ [B] ∈ T" by simp
qed

lemma S_en_T:
"w ∈ S ⟹ w ∈ T"
proof (induct rule: S.induct)
show "[] ∈ T" by (rule T1)
next
fix w
assume "w ∈ S" "w ∈ T"
show "[A] @ w @ [B] ∈ T" using `w ∈ T` by (rule S_en_T_aux1)
next
fix v w
assume "v ∈ S" "v ∈ T" "w ∈ S" "w ∈ T"
show "v @ w ∈ T" using `w ∈ T` `v ∈ T` by (rule S_en_T_aux2)
qed

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

lemma S_igual_T:
"S = T"
by (auto simp add: S_en_T T_en_S)

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

fun balanceada_aux :: "alfabeto list ⇒ nat ⇒ bool" where
"balanceada_aux [] 0 = True"
| "balanceada_aux (A#w) n = balanceada_aux w (Suc n)"
| "balanceada_aux (B#w) (Suc n) = balanceada_aux w n"
| "balanceada_aux w n = False"

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

value "balanceada [A,A,B,B]" -- "= True"
value "balanceada [A,B,A,B]" -- "= True"
value "balanceada [A,B,B,A]" -- "= False"

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

text {*
Nota: En la demostración se usarán los siguientes lemas auxiliares:
· balanceada_correcto_aux_1:
balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)
· balanceada_correcto_aux_2:
⟦balanceada_aux v n;
balanceada_aux w 0⟧
⟹ balanceada_aux (v @ w) n
· balanceada_correcto_aux_3:
w ∈ S ⟹ balanceada_aux w 0 *}

-- "La demostración automática del primer lema auxiliar es"
lemma balanceada_correcto_aux_1:
"balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)"
by (induct w n rule: balanceada_aux.induct) simp_all

-- "La demostración estructurada del primer lema auxiliar es"
lemma balanceada_correcto_aux_1b:
assumes "balanceada_aux w n"
shows "balanceada_aux (w @ [B]) (Suc n)"
using assms
proof (induct w n rule: balanceada_aux.induct)
assume "balanceada_aux [] 0"
thus "balanceada_aux ([] @ [B]) (Suc 0)" by simp
next
fix w n
assume "balanceada_aux w (Suc n) ⟹ balanceada_aux (w @ [B]) (Suc (Suc n))"
"balanceada_aux (A # w) n"
thus "balanceada_aux ((A # w) @ [B]) (Suc n)" by simp
next
fix w n
assume "balanceada_aux w n ⟹ balanceada_aux (w @ [B]) (Suc n)"
"balanceada_aux (B # w) (Suc n)"
thus "balanceada_aux ((B # w) @ [B]) (Suc (Suc n))" by simp
next
fix v
assume "balanceada_aux (B # v) 0"
thus "balanceada_aux ((B # v) @ [B]) (Suc 0)" by simp
next
fix v
assume "balanceada_aux [] (Suc v)"
thus "balanceada_aux ([] @ [B]) (Suc (Suc v))" by simp
qed

-- "La demostración automática del segundo lema auxiliar es"
lemma balanceada_correcto_aux_2:
assumes "balanceada_aux v n"
"balanceada_aux w 0"
shows "balanceada_aux (v @ w) n"
using assms
by (induct v n rule: balanceada_aux.induct) simp_all

-- "La demostración automática del tercer lema auxiliar es"
lemma balanceada_correcto_aux_3:
"w ∈ S ⟹ balanceada_aux w 0"
by (induct rule: S.induct)
(auto simp add: balanceada_correcto_aux_1 balanceada_correcto_aux_2)

-- "La demostración estructurada del tercer lema auxiliar es"
lemma balanceada_correcto_aux_3b:
"w ∈ S ⟹ balanceada_aux w 0"
proof (induct rule: S.induct)
show "balanceada_aux [] 0" by simp
next
fix w
assume "w ∈ S"
"balanceada_aux w 0"
thus "balanceada_aux ([A] @ w @ [B]) 0"
by (simp add: balanceada_correcto_aux_1)
next
fix v w
assume "v ∈ S"
"balanceada_aux v 0"
"w ∈ S"
"balanceada_aux w 0"
thus "balanceada_aux (v @ w) 0"
by (simp add: balanceada_correcto_aux_2)
qed

-- "La demostración automática del tercer lema es"
lemma balanceada_correcto:
"w ∈ S ⟹ balanceada w"
by (simp add: balanceada_correcto_aux_3)

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

-- "La demostración automática del primer lema auxiliar es"
lemma balanceada_completo_aux_1:
"[A,B] ∈ S"
using S1 S2 [where w = "[]"] by simp

-- "La demostración estructurada del primer lema auxiliar es"
lemma balanceada_completo_aux_1b:
"[A,B] ∈ S"
proof -
have "[] ∈ S" using S1 by simp
hence "[A] @ [] @ [B] ∈ S" using S2 [where w = "[]"] by simp
thus "[A,B] ∈ S" by simp
qed

-- "La demostración estructurada del segundo lema auxiliar es"
lemma balanceada_completo_aux_2:
assumes "u ∈ S"
shows "⋀v w. u = v @ w ⟹ v @ A # B # w ∈ S"
using assms
proof (induct)
fix v w :: "alfabeto list"
assume "[] = v @ w"
thus "v @ A # B # w ∈ S" by (simp add: balanceada_completo_aux_1)
next
fix v u w :: "alfabeto list"
assume uS: "u ∈ S" and
HI: "⋀v w. u = v @ w ⟹ v @ A # B # w ∈ S" and
sup: "[A] @ u @ [B] = v @ w"
show "v @ A # B # w ∈ S"
proof (cases v)
case Nil
hence "w = A # u @ [B]" using sup by simp
hence "w ∈ S" using uS S2 by simp
hence "[A,B] @ w ∈ S" using balanceada_completo_aux_1 S3 by blast
thus ?thesis using Nil by simp
next
case (Cons x v')
show ?thesis
proof (cases w rule:rev_cases)
case Nil
have "A # u @ [B] ∈ S" using S2 uS by simp
hence "(A # u @ [B]) @ [A,B] ∈ S"
using balanceada_completo_aux_1 S3 by blast
thus ?thesis using Nil Cons sup by auto
next
case (snoc w' y)
hence u: "u = v' @ w'" and [simp]: "x = A ∧ y = B"
using Cons sup by auto
from u have "v' @ A # B # w' ∈ S" by (rule HI)
hence "A # (v' @ A # B # w') @ [B] ∈ S"
using S2 [where w = "v' @ A # B # w'"] by simp
thus ?thesis using Cons snoc by auto
qed
qed
next
fix v' w' v w
assume v'S: "v' ∈ S"
and HIv: "⋀v w. v' = v @ w ⟹ v @ A # B # w ∈ S"
and w'S: "w' ∈ S"
and HIw: "⋀v w. w' = v @ w ⟹ v @ A # B # w ∈ S"
and sup: "v' @ w' = v @ w"
then obtain r where "v' = v @ r ∧ r @ w' = w ∨ v' @ r = v ∧ w' = r @ w"
(is "?A ∨ ?B")
by (auto simp: append_eq_append_conv2)
thus "v @ A # B # w ∈ S"
proof
assume A: ?A
hence "v @ A # B # r ∈ S" using HIv by blast
hence "(v @ A # B # r) @ w' ∈ S" using w'S by (rule S3)
thus ?thesis using A by auto
next
assume B: ?B
hence "r @ A # B # w ∈ S" using HIw by blast
with v'S have "v' @ (r @ A # B # w) ∈ S" by (rule S3)
thus ?thesis using B by auto
qed
qed

-- "La demostración estructurada del tercer lema auxiliar es"
lemma balanceada_completo_aux_3:
"balanceada_aux w n ⟹ replicate n A @ w ∈ S"
proof (induct w n rule: balanceada_aux.induct)
assume "balanceada_aux [] 0"
thus "replicate 0 A @ [] ∈ S" using S1 by simp
next
fix w n
assume "balanceada_aux w (Suc n) ⟹ replicate (Suc n) A @ w ∈ S"
and "balanceada_aux (A # w) n"
thus "replicate n A @ A # w ∈ S"
by (simp add: replicate_app_Cons_same)
next
fix w n
assume "balanceada_aux w n ⟹ replicate n A @ w ∈ S"
and "balanceada_aux (B # w) (Suc n)"
thus "replicate (Suc n) A @ B # w ∈ S"
by (simp add: balanceada_completo_aux_2
replicate_app_Cons_same[symmetric])
next
fix v
assume "balanceada_aux (B # v) 0"
thus "replicate 0 A @ B # v ∈ S" by simp
next
fix v
assume "balanceada_aux [] (Suc v)"
thus "replicate (Suc v) A @ [] ∈ S" by simp
qed

-- "La demostración del lema es"
lemma balanceada_completo:
assumes "balanceada w"
shows " w ∈ S"
proof -
have "balanceada_aux w 0" using assms by simp
hence "replicate 0 A @ w ∈ S" by (rule balanceada_completo_aux_3)
thus "w ∈ S" by simp
qed

end
</source>

Temas

2015-01-29T12:09:21Z

Jalonso:

== Temas de ''Razonamiento automático (2014-15)'' ==
* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8t.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* Tema 5: Verificación de algoritmos de ordenación:
** [[Tema 5a: Verificación de la ordenación por inserción]].
** [[Tema 5b: Verificación de la ordenación por mezcla]].
* [[Tema 6: Caso de estudio: Compilación de expresiones]].
* Tema 7: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7a: Deducción natural proposicional]].
** [[Tema 7b: 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-8.pdf Tema 8a: Deducción natural en lógica de primer orden]].
** [[Tema 8b: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 9: Conjuntos, funciones y relaciones]].
* [[Tema 10: Conjuntos definidos inductivamente]].
* [[Tema 11: Gramáticas libre de contexto]].
* Tema 12: Misceláneas:
** [[Tema 12a: Razonamiento modular (Teoría de grupos)]].
** [[Tema 12b: Razonamiento modular]].
** [[Tema 12c: Automatización]].
** [[Tema 12d: Pasos elementales]].
** [[Tema 12e: Sudoku]].

Temas

2015-01-29T12:08:57Z

Jalonso:

== Temas de ''Razonamiento automático (2014-15)'' ==
* [[Tema 1: Programación funcional en Isabelle]].
* Tema 2: Razonamiento sobre programas:
** [http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8t.pdf Tema 2a: Razonamiento sobre programas Haskell]
** [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* Tema 5: Verificación de algoritmos de ordenación:
** [[Tema 5a: Verificación de la ordenación por inserción]].
** [[Tema 5b: Verificación de la ordenación por mezcla]].
* [[Tema 6: Caso de estudio: Compilación de expresiones]].
* Tema 7: Deducción natural proposicional:
** [http://www.cs.us.es/~jalonso/cursos/li/temas/tema-2.pdf Tema 7a: Deducción natural proposicional]].
** [[Tema 7b: 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-8.pdf Tema 8a: Deducción natural en lógica de primer orden]].
** [[Tema 8b: Deducción natural en lógica de primer orden con Isabelle/HOL]]
* [[Tema 9: Conjuntos, funciones y relaciones]].
* [[Tema 10: Conjuntos definidos inductivamente]].
* [[Tema 11: Gramáticas libre de contexto]].
* Tema 12: Misceláneas:
* [[Tema 12a: Razonamiento modular (Teoría de grupos)]].
* [[Tema 12b: Razonamiento modular]].
* [[Tema 12c: Automatización]].
* [[Tema 12d: Pasos elementales]].
* [[Tema 12e: Sudoku]].

Temas

2015-01-29T12:05:58Z

Jalonso:

Tema 10: Conjuntos definidos inductivamente

2015-01-22T05:30:07Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 10: Conjuntos definidos inductivamente *} theory T10_Conjuntos_definidos_inductivamente imports Main begin section {* El conjunto de los n...'

<source lang="isar">
header {* Tema 10: Conjuntos definidos inductivamente *}

theory T10_Conjuntos_definidos_inductivamente
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.

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

lemma dvd_imp_par: "2 dvd n ⟹ n ∈ par"
by (auto simp add: dvd_def)

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_dvd:
"n ∈ par ⟹ 2 dvd 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: "2 dvd n"
have "∃k. n = 2*k" using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k" ..
hence "Suc (Suc n) = 2*(k+1)" by auto
hence "∃k. Suc (Suc n) = 2*k" ..
thus "2 dvd Suc (Suc n)" by (simp add: dvd_def)
qed

-- "2ª demostración (con arith)"
lemma par_imp_dvd_2:
"n ∈ par ⟹ 2 dvd 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: "2 dvd n"
thus "2 dvd Suc (Suc n)" by (auto simp add: dvd_def, arith)
qed

-- "3ª demostración (automática)"
lemma par_imp_dvd_3:
"n ∈ par ⟹ 2 dvd 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_dvd: "(n ∈ par) = (2 dvd n)"
by (blast intro: dvd_imp_par par_imp_dvd)

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)
thus "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 ⟶ 2 dvd m) ∧ (n ∈ Impares ⟶ 2 dvd (Suc n))"
proof (induction rule:Pares_Impares.induct)
show "2 dvd (0::nat)" by simp
next
fix n :: "nat"
assume H1: "n ∈ Impares" and
H2: "2 dvd Suc n"
show "2 dvd Suc n" using H2 by simp
next
fix n :: "nat"
assume H1: "n ∈ Pares" and
H2: "2 dvd n"
have "∃k. n = 2*k" using H2 by (simp add: dvd_def)
then obtain k where "n = 2*k" ..
hence "Suc (Suc n) = 2*(k+1)" by auto
hence "∃k. Suc (Suc n) = 2*k" ..
thus "2 dvd 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.
*}

section {* La clausura reflexiva transitiva *}

text {*
· Las definiciones inductivas aceptan parámetros; por tanto, permite
expresar funciones que construyen conjuntos.

· La relaciones binarias son conjuntos de pares; por tanto, se pueden
definir inductivamente.
*}

text {*
· La clausura reflexiva y transitiva de una relación r es la menor
relación reflexiva y transitiva que contiene a r.

· Se representa por r*.

· Se puede definir inductivamente:
· (x,x) ∈ r*
· Si (x,y) ∈ r e (y,z) ∈ r*, entonces (x,z) ∈ r*

· La definición inductiva se puede expresar en Isabelle/HOL como
sigue:
*}

inductive_set
crt :: "('a × 'a) set ⇒ ('a × 'a) set" ("_*" [1000] 999)
for r :: "('a × 'a) set"
where
crt_refl [iff]: "(x,x) ∈ r*"
| crt_paso: "⟦ (x,y) ∈ r; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"

text {*
Notas:
· La sintaxis concreta permite escribir r* en lugar de (crt r).
· La definición consta de dos reglas.
· A la regla reflexiva se le añade el atributo iff para aumentar la
automatización.
· A la regla del paso no se le añade ningún atributo, porque r* ocurre
en la izquierda.
· En el resto de esta sección se demuestra que esta definición
coincide con la menor relación reflexiva y transitiva que contiene a
r.
*}

text {*
Lema. La relación r* contiene a r.
*}

lemma [intro]: "(x,y) ∈ r ⟹ (x,y) ∈ r*"
by (blast intro: crt_paso)

text {*
Notas:
· La ventaja del lema es que se puede declarar como regla de
introducción, porque r* ocurre sólo en la derecha.
· Con la declaración, algunas demostraciones que usan crt_paso se
hacen de manera automática.
*}

text {*
El esquema de inducción de la clausura reflexiva transitiva es
· crt.induct:
⟦(x1, x2) ∈ r*;
⋀x. P x x;
⋀x y z. ⟦(x,y) ∈ r; (y,z) ∈ r*; P y z⟧ ⟹ P x z⟧
⟹ P x1 x2
*}

text {*
Lema. La relación r* es transitiva.
*}

lemma crt_trans: "⟦ (x,y) ∈ r*; (y,z) ∈ r* ⟧ ⟹ (x,z) ∈ r*"
proof (induction rule:crt.induct)
oops

text {*
· El caso base que genera es
⋀x. (y, z) ∈ r* ⟹ (x, z) ∈ r*
que no se puede demostrar.

· El problema está que que en la conclusión no aparece la y. Se puede
reformular como sigue:
*}

lemma crt_trans [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r* ⟶ (x,z) ∈ r*"
proof (induction rule:crt.induct)
show "⋀x. (x,z) ∈ r* ⟶ (x,z) ∈ r*" by simp
next
fix x y u
assume H1: "(x,y) ∈ r" and
H2: "(y,u) ∈ r*" and
H3: "(u,z) ∈ r* ⟶ (y,z) ∈ r*"
show "(u,z) ∈ r* ⟶ (x,z) ∈ r*"
proof
assume "(u,z) ∈ r*"
with H3 have "(y,z) ∈ r*" ..
with H1 show "(x,z) ∈ r*" by (rule crt_paso)
qed
qed

text {*
Notas:
· La reformulación anterior es un caso particular de la siguiente
heurística:
"Para probar una fórmula por inducción sobre (x1,...,xn) ∈ R,
poner todas las premisas conteniendo cualquiera de lax xi en la
conclusión usando ⟶".
· El atributo "rule_format" transforma ⟶ en ⟹.
*}

text {*
(crt2 r) es la menor relación reflexiva y transitiva que contiene a r.
*}

inductive_set
crt2 :: "('a × 'a)set ⇒ ('a × 'a)set"
for r :: "('a × 'a)set"
where
"(x,y) ∈ r ⟹ (x,y) ∈ crt2 r"
| "(x,x) ∈ crt2 r"
| "⟦ (x,y) ∈ crt2 r; (y,z) ∈ crt2 r ⟧ ⟹ (x,z) ∈ crt2 r"

text {*
Lema. La relación (crt2 r) está contenida en r*.
*}

lemma "(x,y) ∈ crt2 r ⟹ (x,y) ∈ r*"
proof (induction rule: crt2.induct)
fix x y
assume "(x,y) ∈ r"
thus "(x,y) ∈ r*" by blast
next
fix x
show "(x,x) ∈ r*" by blast
next
fix x y z
assume H1: "(x,y) ∈ crt2 r" and
H2: "(x,y) ∈ r*" and
H3: "(y,z) ∈ crt2 r" and
H4: "(y,z) ∈ r*"
show "(x,z) ∈ r*" using H2 H4 by (blast intro: crt_trans)
qed

text {*
Lema. La relación r* está contenida en (crt2 r).
*}

lemma "(x,y) ∈ r* ⟹ (x,y) ∈ crt2 r"
proof (induction rule:crt.induct)
fix x
show "(x,x) ∈ crt2 r" by (rule crt2.intros(2))
next
fix x y z
assume H1: "(x,y) ∈ r" and
H2: "(y,z) ∈ r*" and
H3: "(y,z) ∈ crt2 r"
have "(x,y) ∈ crt2 r" using H1 by (rule crt2.intros(1))
thus "(x,z) ∈ crt2 r" using H3 by (rule crt2.intros(3))
qed

text {*
Ejercicio: Demostrar que si (x,y) ∈ r* e (y,z) ∈ r, entonces
(x,z) ∈ r*
*}

lemma crt_paso2 [rule_format]:
"(x,y) ∈ r* ⟹ (y,z) ∈ r ⟶ (x,z) : r*"
proof (induction rule: crt.induct)
fix x
show "(x,z) ∈ r ⟶ (x,z) ∈ r*"
proof
assume "(x,z) ∈ r"
thus "(x,z) ∈ r*" by blast
qed
next
fix x y u
assume H1: "(x,y) ∈ r" and
H2: "(y,u) ∈ r*" and
H3: "(u,z) ∈ r ⟶ (y,z) ∈ r*"
show "(u,z) ∈ r ⟶ (x,z) ∈ r*"
proof
assume "(u,z) ∈ r"
with H3 have "(y,z) ∈ r*" ..
with H1 show "(x,z) ∈ r*" by (rule crt_paso)
qed
qed

section {* Definiciones inductivas avanzadas *}

subsection {* Cuantificadores universales en las reglas de introducción
(términos básicos) *}

text {*
Como caso de estudio se presenta la teoría de los términos básicos
(i.e. sin variables).
*}

text {*
· Un término básico se obtiene aplicando una función a una lista de
términos básicos.

· Las constantes se representan mediante funciones 0-arias.

· terminoB es el tipo de los términos básicos.
*}

datatype 'f terminoB = Aplica 'f "'f terminoB list"

text {*
op_entera es el tipo de las operaciones enteras y está formado por las
constantes enteras, el opuesto y la suma.
*}

datatype op_entera = Numero int | Opuesto | Suma

text {*
El tipo "op_entera terminoB" está formado por los términos básicos con
operaciones enteras.
*}

text {*
El conjunto de los téminos básicos sobre un conjunto de símbolos de
función F se define inductivamente:
si f ∈ F y t1,...,tn son términos básicos sobre F, entonces
f(t1,...,tn) es un término básico sobre F.
*}

inductive_set terminosB :: "'f set ⇒ 'f terminoB set"
for F :: "'f set"
where
paso [intro!]: "⟦∀t ∈ set args. t ∈ terminosB F; f ∈ F⟧
⟹ (Aplica f args) ∈ terminosB F"

text {*
Ejemplo de demostración sobre el conjunto de los términos básicos:
Lema: terminosB es monótona; es decir, si F ⊆ G, entonces
terminosB F ⊆ terminosB G.
*}

lemma terminosB_mono:
assumes "F ⊆ G"
shows "terminosB F ⊆ terminosB G"
proof -
have "⋀x. x ∈ terminosB F ⟹ x ∈ terminosB G"
proof (rule terminosB.induct)
fix x ys f
assume H1: "∀t ∈ set ys. t ∈ terminosB F ∧ t ∈ terminosB G" and
H2: "f ∈ F"
have "∀t ∈ set ys. t ∈ terminosB G" using H1 by simp
thus "(Aplica f ys) ∈ terminosB G" using assms H2 by blast
qed
thus ?thesis ..
qed

text {*
· La aridad de un símbolo de función es el número de argumentos a los
que se puede aplicar.

· Un término está bien formado si la longitud de la lista de
argumentos de cada símbolo de función es igual a su aridad.
*}

inductive_set
terminoB_bien_formado :: "('f ⇒ nat) ⇒ 'f terminoB set"
for aridad :: "'f ⇒ nat"
where
paso [intro!]: "⟦∀t ∈ set args. t ∈ terminoB_bien_formado aridad;
length args = aridad f⟧
⟹ (Aplica f args) ∈ terminoB_bien_formado aridad"

subsection {* Definición alternativa mediante una función monótona *}

text {*
En la siguiente definición se usa
· "lists A" que es el conjunto de las listas cuyos elementos
pertenecen conjunto A. Está definido en la teoría Lists por
inductive_set
lists :: "'a set => 'a list set"
for A :: "'a set"
where
"[] ∈ lists A"
| "⟦ a ∈ A; l ∈ lists A ⟧ ⟹ a # l ∈ lists A"

· Para demostrar la terminación, se usa el lema
lists_mono: A ⊆ B ⟹ lists A ⊆ lists B
*}

inductive_set
terminoB_bien_formado' :: "('f ⇒ nat) ⇒ 'f terminoB set"
for aridad :: "'f ⇒ nat"
where
paso [intro!]: "⟦args ∈ lists (terminoB_bien_formado' aridad);
length args = aridad f⟧
⟹ (Aplica f args) ∈ terminoB_bien_formado' aridad"
monos lists_mono

text {*
El uso de lists_mono no es necesario. Se incluye para mostrar la
sintaxis de la declaración de "monos".
*}

subsection {* Demostración de equivalencia *}

lemma
"terminoB_bien_formado aridad ⊆ terminoB_bien_formado' aridad"
proof -
have "⋀x. x ∈ terminoB_bien_formado aridad ⟹
x ∈ terminoB_bien_formado' aridad"
proof (erule terminoB_bien_formado.induct)
fix x ys f
assume H1: "∀t ∈ set ys. t ∈ terminoB_bien_formado aridad ∧
t ∈ terminoB_bien_formado' aridad" and
H2: "length ys = aridad f"
thus "Aplica f ys ∈ terminoB_bien_formado' aridad" by auto
qed
thus ?thesis ..
qed

lemma
"terminoB_bien_formado' aridad ⊆ terminoB_bien_formado aridad"
proof -
have "⋀x. x ∈ terminoB_bien_formado' aridad ⟹
x ∈ terminoB_bien_formado aridad"
proof (erule terminoB_bien_formado'.induct)
fix x ys f
assume H1: "ys ∈ lists (terminoB_bien_formado' aridad ∩
{a. a ∈ terminoB_bien_formado aridad})" and
H2: "length ys = aridad f"
have "ys ∈ lists (terminoB_bien_formado' aridad) ∩
lists (terminoB_bien_formado aridad)"
using H1 by (simp add: lists_Int_eq)
hence "ys ∈ lists (terminoB_bien_formado aridad)" by simp
thus "Aplica f ys ∈ terminoB_bien_formado aridad" using H2 by auto
qed
thus ?thesis ..
qed

-- "La demostración anterior se puede simplificar:"
lemma
"terminoB_bien_formado' aridad ⊆ terminoB_bien_formado aridad"
proof -
have "⋀x. x ∈ terminoB_bien_formado' aridad ⟹
x ∈ terminoB_bien_formado aridad"
proof (erule terminoB_bien_formado'.induct)
fix x ys f
assume "ys ∈ lists (terminoB_bien_formado' aridad ∩
{a. a ∈ terminoB_bien_formado aridad})"
"length ys = aridad f"
thus "Aplica f ys ∈ terminoB_bien_formado aridad" by auto
qed
thus ?thesis ..
qed

end
</source>

Temas

2015-01-22T05:29:16Z

Jalonso:

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

Documentación

2015-01-09T07:05:11Z

Jalonso: /* Otros cursos */

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

== Visiones generales de la DAO ==

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

== Referencias sobre Isabelle/HOL ==
# B. Grechuk [http://dream.inf.ed.ac.uk/projects/isabelle/Isabelle_Primer.pdf Isabelle primer for mathematicians].
# T. Nipkow [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/prog-prove.pdf Programming and proving in Isabelle/HOL]. 5 de diciembre de 2013.
# T. Nipkow, M. Wenzel y L.C. Paulson [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/tutorial.pdf A proof assistant for higher-order logic]. Springer-Verlag. 5 de diciembre de 2013.
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/library/HOL/HOL/document.pdf Isabelle/HOL — Higher-Order Logic]. 5 de diciembre de 2013.
# M. Wenzel [http://www.cl.cam.ac.uk/research/hvg/Isabelle/dist/Isabelle2013-2/doc/isar-ref.pdf The Isabelle/Isar Reference Manual]. 5 de diciembre de 2013.
# M. Wenzel [https://www.lri.fr/~wenzel/Isabelle2011-Paris/quickref.pdf The Isabelle/Isar quick reference].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref.pdf Quick Reference for Isabelle/Isar Propositional Logic].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref2.pdf Quick Reference for Isabelle/Isar More Proof Techniques].
# J. Siek [http://ecee.colorado.edu/~siek/ecen3703/spring10/quick-ref3.pdf Quick Reference for Isabelle/Isar First-Order Logic].
# [http://www.cl.cam.ac.uk/research/hvg/Isabelle/documentation.html Tutorials and manuals for Isabelle2013].

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

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

== Cursos relacionados ==
=== Cursos con Isabelle/HOL ===
# Jeremy Avigad. [http://www.phil.cmu.edu/~avigad/formal/ Logic and Formal Verification]. (Carnegie Mellon, 2009).
# Clemens Ballarin. [http://cl-informatik.uibk.ac.at/teaching/ss08/atp/introduction.php Automatic Deduction]. (Univ de Innsbruck, 2008).
# Clemens Ballarin. [http://www4.in.tum.de/~ballarin/belgrade08-tut/ Introduction to the Isabelle Proof Assistant]. (Belgrado, 2008).
# Clemens Ballarin y Gerwin Klein [http://isabelle.in.tum.de/coursematerial/IJCAR04 Introduction to the Isabelle Proof Assistant]. (en el IJCAR-2004).
# Clemens Ballarin y Tjark Weber. [http://cl-informatik.uibk.ac.at/teaching/ws06/atp/introduction.php Automated Theorem Proving in Isabelle/HOL]. (Univ. de Innsbruck, 2006-07).
# A.D. Brucker, D. Basin, J.G. Smaus y B. Wolff. [http://archiv.infsec.ethz.ch/education/permanent/csmr.html Computer-supported Modeling and Reasoning]. (ETH Zurich, 2011).
# Mads Dam. [http://www.csc.kth.se/utbildning/kth/kurser/DD2453/aform07/ Advanced formal methods]. (KTH Royal Institute of Technology, 2007).
# Jacques Fleuriot y Paul Jackson. [http://www.inf.ed.ac.uk/teaching/courses/ar/slides/ Automated reasoning]. (Univ. de Edimburgo, 2012-13).
# Thomas Genet [http://www.irisa.fr/celtique/genet/ACF Software formal analysis and design]. (Univ. de Rennes)
# Gerwin Klein. [http://www.cse.unsw.edu.au/~kleing/teaching/thprv-04 Theorem Proving - Principles, Techniques, Applications]. (NICTA, 2004).
# Gerwin Klein. [http://www.cse.unsw.edu.au/~cs4161/index.html Advanced Topics in Software Verification]. (NICTA, 2012).
# Joao Marcos. [http://www.dimap.ufrn.br/~jmarcos/courses/LC/Ementa.htm Lógica computacional: Demonstração assistida e semi-automática de teoremas].(UFRN, 2000).
# Tobias Nipkow. [http://www4.informatik.tu-muenchen.de/~nipkow/semantics/ Semantics of programming languages]. (Univ. de Munich, 2012-13).
# Tobias Nipkow [http://isabelle.in.tum.de/coursematerial/PSV2009-1 Theorem Proving with Isabelle/HOL An Intensive Course].
# Larry Paulson. [http://www.cl.cam.ac.uk/teaching/0910/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2009-10).
# Arnd Poetzsch-Heffter. [https://softech.informatik.uni-kl.de/Homepage/SVHOL10 Specification and Verification with Higher-Order Logic].
# Viorel Preoteasa, Ralph-Johan Back y Charmi Panchal. [http://users.abo.fi/vpreotea/isabelle-2012 Introduction to mechanized reasoning with Isabelle/HOL]. (Åbo Akademi University, 2012).
# Jeremy G. Siek. [http://www.cs.colorado.edu/~siek/7000/spring07/ Practical Theorem Proving with Isabelle/Isar]. (Univ. de Colorado, 2007).
# Jeremy G. Siek. [http://ecee.colorado.edu/~siek/ecen5013/spring11/ Theorem proving in Isabelle]. (Univ. de Colorado, 2011).
# Jan-Georg Smaus. [http://www.informatik.uni-freiburg.de/~ki/teaching/ws0910/csmr/lecture.html Computer-supported modeling and reasoning]. (Univ. de Feiburgo, 2009).
# Christian Sternagel [http://cl-informatik.uibk.ac.at/teaching/ss11/eve/content.php Experiments in Verification – Introduction to Isabelle/HOL]. (Univ. de Innsbruck, 2011-12).
# Tjark Weber. [http://www.cl.cam.ac.uk/teaching/1011/L21/ Interactive Formal Verification]. (Univ. de Cambridge, 2010-11).

=== Otros cursos ===
# José A. Alonso [http://www.cs.us.es/~jalonso/cursos/li/ Lógica informática] (Univ. de Sevilla, 2012-13).
# Thorsten Altenkirch y Peter Morris [http://www.cs.nott.ac.uk/~txa/g52ifr Introduction to formal reasoning] (Univ. de Nottingham, 2010-11).
# Yves Bertot, Pierre Casteran, Benjamin Gregoire, Pierre Letouzey y Assia Mahboubi [http://www.di.ens.fr/~zappa/teaching/coq/ecole11 Modelling and verifying algorithms in Coq: an introduction]. (INRIA Paris-Rocquencourt, 14-18 noviembre 2011).
# Pierre Castéran [http://www.labri.fr/perso/casteran/FM/Logique/index.html Logic (Master In Verification)] (Univ. de Burdeos, 2011-12).
# Adam Chlipala [http://stellar.mit.edu/S/course/6/fa11/6.892/ Interactive computer theorem proving]. (MIT, 2012-13).
# Adam Chlipala y Armando Solar Lezama [https://stellar.mit.edu/S/course/6/fa13/6.820/index.html Foundations of program analysis]. (MIT, 2013-14).
# Robby Findler [http://www.eecs.northwestern.edu/~robby/courses/395-495-2013-fall Certified programming with dependent types]. (Northwestern, 2013-14).
# Nuno Gaspar [http://www-sop.inria.fr/members/Nuno.Gaspar/teaching/coq2012.php Verification with the Coq Proof Assistant] (INRIA Sophia Antipolis, 2012-13).
# Carlos Luna y Gustavo Betarte. [https://eva.fing.edu.uy/course/view.php?id=363 Construcción formal de programas en teoría de tipos]. (Univ. de la República, Uruguay, 2013-14).
# Michael Genesereth [http://logic.stanford.edu/classes/cs157/2011/cs157.html Computational Logic] (Univ. de Stanford, 2011-12).
# Ian Hodkinson [http://www.doc.ic.ac.uk/~imh/teaching/140_logic/logic.html Logic] (Imperial College, Londres, 2010-11).
# Peter Lucas [http://www.cs.ru.nl/~peterl/teaching/KeR/ Knowledge Representation and Reasoning] (Radboud University # egen, 2011-12).
# Larry Paulson [http://www.cl.cam.ac.uk/Teaching/current/LogicProof/ Logic and Proof] (Univ. de Cambridge, 2011-12).
# Michael Winter [Logic in Computer Science] (Brock University, Ontario, Canada, 2010-11).

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

== Artículos recientes ==
Están en orden cronológico inverso a la fecha de su reseña en [http://www.glc.us.es/~jalonso/vestigium/tag/resena Vestigium]:
# [http://bit.ly/1iZjgqN Proof Pearl: A probabilistic proof for the Girth-Chromatic number theorem]. L. Noschinski
# [http://bit.ly/1iJ8uVz A graph library for Isabelle]. ~ L. Noschinski
# [http://bit.ly/I0CU80 Gödel’s incompleteness theorems]. ~ L.C. Paulson
# [http://bit.ly/I0CPRN The hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/HBiIJI Applications of real number theorem proving in PVS]. ~ H. Gottliebsen, R. Hardy, O. Lightfoot y U. Martin
# [http://bit.ly/1awnMLB A machine-assisted proof of Gödel’s incompleteness theorems for the theory of hereditarily finite sets]. ~ L.C. Paulson
# [http://bit.ly/19lWeYy Verified AIG algorithms in ACL2]. ~ J. Davis y S. Swords
# [http://bit.ly/GAhC00 A formal model and correctness proof for an access control policy framework]. ~ C. Wu, X. Zhang y C. Urban
# [http://bit.ly/16SMvSS The ontological argument in PVS]. ~ J. Rushby
# [http://bit.ly/1dRt9n0 Formalizing Moessner’s theorem and generalizations in Nuprl]. ~ M. Bickford, D. Kozen y A. Silva
# [http://bit.ly/1bSeDNB Formalization in PVS of balancing properties necessary for the security of the Dolev-Yao cascade protocol model]. ~ M. Ayala y Y. Santos
# [http://bit.ly/1feFqWE Proof assistant based on didactic considerations]. ~ J. Pais y A Tasistro
# [http://bit.ly/18tHNBi Theory exploration for interactive theorem proving]. ~ M. Johansson
# [http://bit.ly/1b0242s From Tarski to Hilbert]. ~ G. Braun y J. Narboux
# [http://bit.ly/18HaXaR Formal verification of language-based concurrent noninterference]. ~ A. Popescu, J. Hölzl y T. Nipkow
# [http://bit.ly/1aRTQsU A Traffic Alert and Collision Avoidance System(TCAS-II) Resolution Advisory Algorithm]. ~ C. Muñoz, A. Narkawicz y J. Chamberlain
# [http://bit.ly/1dNwhDI Formal verification of cryptographic security proofs]. ~ M. Berg
# [http://bit.ly/17muAUv Polygonal numbers in Mizar]. ~ A. Grabowski
# [http://bit.ly/1hk5z6L A mechanised proof of Gödel’s incompleteness theorems using Nominal Isabelle]. ~ L.C. Paulson
# [http://bit.ly/1cSL0wE Steps towards verified implementations of HOL Light]. ~ M.O. Myreen, S. Owens y R. Kumar
# [http://bit.ly/16Kbgm0 Generic datatypes à la carte]. ~ S. Keuchel y T. Schrijvers
# [http://bit.ly/1bqJGx4 Proof pearl: A verified bignum implementation in x86-64 machine code]. ~ M.O. Myreen y G. Curello
# [http://bit.ly/142ow2Q Mechanized metatheory for a λ λ-calculus with trust types]. ~ R. Ribeiro, C. Camarão y L. Figueiredo
# [http://bit.ly/15WZBDy Proving soundness of combinatorial Vickrey auctions and generating verified executable code]. ~ M.B. Caminati, M. Kerber, C. Lange y C. Rowat
# [http://bit.ly/198g4n9 A computer-assisted proof of correctness of a marching cubes algorithm]. ~ A.N. Chernikov y J. Xu
# [http://bit.ly/11QA5g7 Verifying the bridge between simplicial topology and algebra: the Eilenberg-Zilber algorithm]. ~ L. Lambán, J. Rubio, F.J. Martín y J.L. Ruiz
# [http://bit.ly/1cJAXYk The Königsberg bridge problem and the friendship theorem]. ~ W. Li
# [http://bit.ly/13DBK9R Formal verification of a proof procedure for the description logic ALC]. ~ M. Chaabani, M. Mezghiche y M. Strecker
# [http://bit.ly/1ep2ex9 Pratt’s primality certificates]. ~ S. Wimmer y L. Noschinski
# [http://bit.ly/13C95Ci Reasoning about higher-order relational specifications]. ~ Y. Wang, K. Chaudhuri, A. Gacek y G. Nadathur
# [http://bit.ly/18QQLcL Proofs you can believe in – Proving equivalences between Prolog semantics in Coq]. ~ J. Kriener, A. King y S. Blazy
# [http://bit.ly/19uc82J Certified, efficient and sharp univariate Taylor models in Coq]. ~ E. Martin-Dorel, L. Rideau, L. Théry, M. Mayero y I. Paşca
# [http://bit.ly/1c4Rzel Ordinals in HOL: Transfinite arithmetic up to (and beyond) ω₁]. ~ M. Norrish y B. Huffman
# [http://bit.ly/14b4Akz Program verification based on Kleene algebra in Isabelle/HOL] ~ A. Armstrong, G. Struth y T. Weber
# [http://bit.ly/1aOgRKx Reading an algebra textbook (by translating it to a formal document in the Isabelle/Isar language)]. ~ C. Ballarin
# [http://bit.ly/11HKixj Computational verification of network programs in Coq]. ~ G. Stewart
# [http://www.glc.us.es/~jalonso/vestigium/resena-certifying-homological-algorithms-to-study-biomedical-images Certifying homological algorithms to study biomedical images]. ~ M. Poza
# [http://bit.ly/16Nks9m Formalizing cut elimination of coalgebraic logics in Coq]. ~ H. Tews
# [http://www.glc.us.es/~jalonso/vestigium/resena-the-formalization-of-syntax-based-mathematical-algorithms-using-quotation-and-evaluation/ The formalization of syntax-based mathematical algorithms using quotation and evaluation]. ~ W.M. Farmer
# [http://www.glc.us.es/~jalonso/vestigium/resena-certified-symbolic-manipulation-bivariate-simplicial-polynomials/ Certified symbolic manipulation: Bivariate simplicial polynomials]. ~ L. Lambán, F.J. Martín, J. Rubio y J.L. Ruiz
# [http://www.glc.us.es/~jalonso/vestigium/resena-solveurs-cpfd-verifies-formellement/ Solveurs CP(FD) vérifiés formellement]. ~ C Dubois y A. Gotlieb
# [http://www.glc.us.es/~jalonso/vestigium/resena-formalizing-bounded-increase/ Formalizing bounded increase]. ~ R. Thiemann
# [http://www.glc.us.es/~jalonso/vestigium/resena-formal-mathematics-on-display-a-wiki-for-flyspeck/ Formal mathematics on display: A wiki for Flyspeck]. ~ C. Tankink, C. Kaliszyk, J. Urban y H. Geuvers
# [http://www.glc.us.es/~jalonso/vestigium/resena-theorem-of-three-circles-in-coq Theorem of three circles in Coq]. ~ J. Zsidó
# [http://bit.ly/19fiWAY Certified HLints with Isabelle/HOLCF-Prelude]. ~ J. Breitner, B. Huffman, N. Mitchell y C. Sternagel
# [http://bit.ly/ZfSQrQ Automatic data refinement]. ~ P. Lammich
# [http://bit.ly/18vyjm7 The rooster and the butterflies (a machine-checked proof of the Jordan-Hölder theorem for finite groups)]. ~ A. Mahboubi
# [http://bit.ly/114oyZV Mechanical verification of SAT refutations with extended resolution]. ~ N. Wetzler, M.J.H. Heule y W.A. Hunt Jr.
# [http://bit.ly/13H0REu Type classes and filters for mathematical analysis in Isabelle/HOL] ~ J. Hölzl, F. Immler y B. Huffman
# [http://bit.ly/10fv8wO Verifying refutations with extended resolution]. ~ M. J. H. Heule, W. A. Hunt, Jr. y N. Wetzler
# [http://bit.ly/10EcFWj A Web interface for Isabelle: The next generation]. ~ C. Lüth y M. Ring
# [http://bit.ly/18P9CSv On the formalization of continuous-time Markov chains in HOL]. ~ L. Liu, O. Hasan y S. Tahar
# [http://bit.ly/17H2mqy Formalizing Turing machines]. ~ A. Asperti y W. Ricciotti
# [http://bit.ly/YwuCeL Light-weight containers for Isabelle: efficient, extensible, nestable]. ~ A. Lochbihler
# [http://bit.ly/10XLrRA Graph theory]. ~ L. Noschinski
# [http://bit.ly/19kPEP4 A machine-checked proof of the odd order theorem]. ~ G. Gonthier et als.
# [http://goo.gl/LdihL A constructive theory of regular languages in Coq]. ~ C. Doczkal, J.O. Kaiser y G. Smolka
# [http://goo.gl/gwcwL A formal proof of Kruskal’s tree theorem in Isabelle/HOL]. ~ C. Sternagel
# [http://goo.gl/CUF3e Formalizing Knuth-Bendix orders and Knuth-Bendix completion]. ~ C. Sternagel y R. Thiemann
# [http://goo.gl/9JAfX Developing an auction theory toolbox]. ~ C. Lange, C. Rowat, W. Windsteiger y M. Kerber
# [http://goo.gl/6OfmQ Formalization of incremental simplex algorithm by stepwise refinement]. ~ M. Spasić y F. Marić
# [http://goo.gl/Guxky Coinductive pearl: Modular first-order logic completeness]. ~ J.C. Blanchette, A. Popescu y D. Traytel
# [http://goo.gl/HUOl8 A fully verified executable LTL model checker]. ~ J. Esparza et als.
# [http://goo.gl/RV54S ForMaRE - formal mathematical reasoning in economics]. ~ M. Kerber, C. Lange y C. Rowat.
# [http://goo.gl/Y7sIq AI over large formal knowledge bases: The first decade]. ~ J. Urban.
# [http://goo.gl/vvqNg Formalization of real analysis: A survey of proof assistants and libraries]. ~ S. Boldo, C. Lelay y G. Melquiond.
# [http://goo.gl/bEFYa Data refinement in Isabelle/HOL]. ~ F. Haftmann, A. Krauss, O. Kunčar y T. Nipkow
# [http://goo.gl/xTyvE Formalizing the confluence of orthogonal rewriting systems]. ~ A.C. Rocha y M. Ayala.
# [http://goo.gl/zCYHj Formalization of the complex number theory in HOL4]. ~ Z. Shi et als.
# [http://goo.gl/kM0dI Programming and reasonning with PowerLists in Coq]. ~ F. Loulergue y V. Niculescu
# [http://goo.gl/KkU6s A hierarchy of mathematical structures in ACL2]. ~ J. Heras, F.J. Martín y V. Pascual.
# [http://www.inf.kcl.ac.uk/staff/urbanc/Publications/tm.pdf Mechanising Turing Machines and Computability Theory in Isabelle/HOL] ~ J. Xu, X. Zhang y C. Urban

Relación 11

2015-01-08T12:50:26Z

Jalonso: Página creada con '<source lang="isar"> header {* R11: Plegados de listas y de árboles *} theory R11 imports Main begin section {* Nuevas funciones sobre listas *} text {* Nota. En esta r...'

<source lang="isar">
header {* R11: Plegados de listas y de árboles *}

theory R11
imports Main
begin

section {* Nuevas funciones sobre listas *}

text {*
Nota. En esta relación se usará la función suma tal que (suma xs) es
la suma de los elementos de xs, definida por
*}

fun suma :: "nat list ⇒ nat" where
"suma xs = undefined"

text {*
Las funciones de plegado, foldr y foldl, están definidas en la teoría
List.thy por
foldr :: "('a ⇒ 'b ⇒ 'b) ⇒ 'a list ⇒ 'b ⇒ 'b"
foldr f [] = id
foldr f (x # xs) = f x ∘ foldr f xs

foldl :: "('b ⇒ 'a ⇒ 'b) ⇒ 'b ⇒ 'a list ⇒ 'b"
foldl f a [] = a
foldl f a (x # xs) = foldl f (f a x) xs"

Por ejemplo,
foldr (op +) [a,b,c] d = a + (b + (c + d))
foldl (op +) d [a,b,c] = ((d + a) + b) + c
foldr (op -) [9,4,2] (0::int) = 7
foldl (op -) (0::int) [9,4,2] = -15
*}

value "foldr (op +) [a,b,c] d" -- "= a + (b + (c + d))"
value "foldl (op +) d [a,b,c]" -- "= ((d + a) + b) + c"
value "foldr (op -) [9,4,2] (0::int)" -- "= 7"
value "foldl (op -) (0::int) [9,4,2]" -- "= -15"

text {*
---------------------------------------------------------------------
Ejercicio 1. Demostrar que
suma xs = foldr (op +) xs 0
---------------------------------------------------------------------
*}

lemma suma_foldr: "suma xs = foldr (op +) xs 0"
oops

text {*
---------------------------------------------------------------------
Ejercicio 2. Demostrar que
length xs = foldr (λ x res. 1 + res) xs 0
---------------------------------------------------------------------
*}

lemma length_foldr: "length xs = foldr (λ x res. 1 + res) xs 0"
oops

text {*
---------------------------------------------------------------------
Ejercicio 3. La aplicación repetida de foldr y map tiene el
inconveniente de que la lista se recorre varias veces. Sin embargo, es
suficiente recorrerla una vez como se muestra en el siguiente ejemplo,
suma (map (λx. x + 3) xs) = foldr h xs b
Determinar los valores de h y b para que se verifique la igualdad
anterior y demostrarla.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 4. Generalizar el resultado anterior; es decir determinar
los valores de h y b para que se verifique la igualdad
foldr g (map f xs) a = foldr h xs b
y demostrarla.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 5. La siguiente función invierte una lista en tiempo lineal
fun inversa_ac :: "['a list, 'a list] ⇒ 'a list" where
"inversa_ac [] ys = ys"
| "inversa_ac (x#xs) ys = (inversa_ac xs (x#ys))"

definition inversa_ac :: "'a list ⇒ 'a list" where
"inversa_ac xs ≡ inversa_ac_aux xs []"
Por ejemplo,
inversa_ac [a,d,b,c] = [c, b, d, a]
Demostrar que inversa_ac se puede definir unsando foldl.
---------------------------------------------------------------------
*}

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

definition inversa_ac :: "'a list ⇒ 'a list" where
"inversa_ac xs ≡ inversa_ac_aux xs []"

value "inversa_ac [a,d,b,c]" -- "= [c, b, d, a]"

lemma inversa_ac_aux_foldl:
"inversa_ac_aux xs a = foldl undefined a xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 6. Demostrar la siguiente propiedad distributiva de la suma
sobre la concatenación:
suma (xs @ ys) = suma xs + suma ys
---------------------------------------------------------------------
*}

lemma suma_append [simp]:
"suma (xs @ ys) = suma xs + suma ys"
oops

text {*
---------------------------------------------------------------------
Ejercicio 7. Demostrar una propiedad similar para foldr
foldr f (xs @ ys) a = f (foldr f xs a) (foldr f ys a)
En este caso, hay que restringir el resultado teniendo en cuenta
propiedades algebraicas de f y a.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 8. Definir, usando foldr, la función
prod :: "nat list ⇒ nat"
tal que (prod xs) es el producto de los elementos de xs. Por ejemplo,
---------------------------------------------------------------------
*}

definition prod :: "nat list ⇒ nat" where
"prod xs ≡ undefined"

value "prod [2::nat,3,5]" -- "= 30"

text {*
---------------------------------------------------------------------
Ejercicio 9. Demostrar directamente (es decir, sin inducción) que
prod (xs @ ys) = prod xs * prod ys
---------------------------------------------------------------------
*}

lemma "prod (xs @ ys) = prod xs * prod ys"
oops

section {* Functiones sobre árboles *}

text {*
---------------------------------------------------------------------
Ejercicio 10. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información sólo en los nodos. Por ejemplo,
el árbol
e
/ \
/ \
c g
/ \ / \
· · · ·
se representa por "N (N H c H) e (N H g H)"
---------------------------------------------------------------------
*}

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

value "N (N H c H) e (N H g H)"

text {*
---------------------------------------------------------------------
Ejercicio 11. 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 (N H c H) e (N H g H))
= [e,c,g]
---------------------------------------------------------------------
*}

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden t = undefined"

value "preOrden (N (N H c H) e (N H g H))"
-- "= [e,c,g]"

text {*
---------------------------------------------------------------------
Ejercicio 12. 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 (N H c H) e (N H g H))
= [c,g,e]
---------------------------------------------------------------------
*}

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden t = undefined"

value "postOrden (N (N H c H) e (N H g H))"
-- "= [c,g,e]"

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

fun postOrdenAaux :: "['a arbol, 'a list] ⇒ 'a list" where
"postOrdenAaux t = undefined"

definition postOrdenA :: "'a arbol ⇒ 'a list" where
"postOrdenA a ≡ undefined"

value "postOrdenA (N (N H c H) e (N H g H))"
-- "= [c,g,e]"

text {*
---------------------------------------------------------------------
Ejercicio 14. Demostrar que
postOrdenAaux a xs = (postOrden a) @ xs
---------------------------------------------------------------------
*}

lemma "postOrdenAaux a xs = (postOrden a) @ xs"
oops

text {*
---------------------------------------------------------------------
Ejercicio 15. Definir la función
foldl_arbol :: "('b => 'a => 'b) ⇒ 'b ⇒ 'a arbol ⇒ 'b" where
tal que (foldl_arbol f b a) es el plegado izquierdo del árbol a con la
operación f y elemento inicial b.
---------------------------------------------------------------------
*}

fun foldl_arbol :: "('b => 'a => 'b) ⇒ 'b ⇒ 'a arbol ⇒ 'b" where
"foldl_arbol f b t = undefined"

text {*
---------------------------------------------------------------------
Ejercicio 16. Demostrar que
postOrdenAaux t a = foldl_arbol (λ xs x. Cons x xs) a t
---------------------------------------------------------------------
*}

lemma "postOrdenAaux t a = foldl_arbol (λ xs x. Cons x xs) a t"
oops

text {*
---------------------------------------------------------------------
Ejercicio 17. Definir la función
suma_arbol :: "nat arbol ⇒ nat"
tal que (suma_arbol a) es la suma de los elementos del árbol de
números naturales a.
---------------------------------------------------------------------
*}

fun suma_arbol :: "nat arbol ⇒ nat" where
"suma_arbol t = undefined"

text {*
---------------------------------------------------------------------
Ejercicio 18. Demostrar que
suma_arbol a = suma (preOrden a)"
---------------------------------------------------------------------
*}

lemma "suma_arbol a = suma (preOrden a)"
oops

end
</source>

R11

2015-01-08T12:49:58Z

Ejercicios

2015-01-08T12:49:02Z

Jalonso: /* Relaciones de ejercicios */

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

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

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

Tema 9: Conjuntos, funciones y relaciones

2015-01-06T12:42:20Z

Jalonso:

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

theory T9
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

subsection {* Notación de conjuntos finitos *}

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

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

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

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

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

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

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

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

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

text {*
Ejemplo con la conjetura corregida.
*}

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

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

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

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

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

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

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

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

declare sumaConj_def[simp]
declare sumaCuadradosConj_def[simp]

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

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

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

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

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

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

subsection {* Definiciones por comprensión *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- "La demostración detallada es"
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" by (rule IntD1)
hence "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" by (rule IntD2)
hence "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

-- "La demostración estructurada es"
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" ..
hence "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" ..
hence "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

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

subsection {* Cuantificadores acotados *}

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

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

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

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

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

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

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

subsection {* Conjuntos finitos y cardinalidad *}

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

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

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

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

section {* Funciones *}

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

subsection {* Nociones básicas de funciones *}

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

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

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

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

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

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

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

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

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

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

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

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

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

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

-- "La demostración estructurada es"
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
thus "g = h" using `inj f` by (simp add: inj_on_def fun_eq_iff)
next
assume "g = h"
thus "f ∘ g = f ∘ h" by auto
qed

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

subsubsection {* Función imagen *}

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

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

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

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

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

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

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

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

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

section {* Relaciones *}

subsection {* Relaciones básicas *}

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

Las relaciones son conjuntos de pares.

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

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

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

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

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

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

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

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

subsection {* Clausura reflexiva y transitiva *}

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

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

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

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

Inducción sobre la clausura reflexiva y transitiva
· rtrancl_induct: ⟦(a,b) ∈ r⇧*;
P b;
⋀y z. ⟦(y,z) ∈ r; (z,b) ∈ r⇧*; P z⟧ ⟹ P y⟧
⟹ P a

Idempotencia de la clausura reflexiva y transitiva:
· rtrancl_idemp: (r⇧* )⇧* = r⇧*

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

Ejemplo de propiedad:
· trancl_converse: (r¯)⇧+ = (r⇧+)¯
*}

subsection {* Una demostración elemental *}

text {*
Se desea demostrar que la clausura reflexiva y transitiva conmuta con
la inversa (cl_rtrans_inversa).
*}

theorem "(r¯)⇧* = (r⇧*)¯"
oops

text {* Para demostrarlo introducimos dos lemas auxiliares:
cl_rtrans_inversaD y cl_rtrans_inversaI.
*}

-- "La demostración detallada del primer lema es"
lemma cl_rtrans_inversaD:
"(x,y) ∈ (r¯)⇧* ⟹ (y,x) ∈ r⇧*"
proof (induct rule:rtrancl_induct)
show "(x,x) ∈ r⇧*" by (rule rtrancl_refl)
next
fix y z
assume "(x,y) ∈ (r¯)⇧*" and "(y,z) ∈ r¯" and "(y,x) ∈ r⇧*"
show "(z,x) ∈ r⇧*"
proof (rule rtrancl_trans)
show "(z,y) ∈ r⇧*" using `(y,z) ∈ r¯` by simp
next
show "(y,x) ∈ r⇧*" using `(y,x) ∈ r⇧*` by simp
qed
qed

-- "La demostración automática del primer lema es"
lemma cl_rtrans_inversaD2:
"(x,y) ∈ (r¯)⇧* ⟹ (y,x) ∈ r⇧*"
by (induct rule: rtrancl_induct)
(auto simp add: rtrancl_trans)

-- "La demostración detallada del segundo lema es"
lemma cl_rtrans_inversaI:
"(y,x) ∈ r⇧* ⟹ (x,y) ∈ (r¯)⇧*"
proof (induct rule: rtrancl_induct)
show "(y,y) ∈ (r¯)⇧*" by (rule rtrancl_refl)
next
fix u z
assume "(y,u) ∈ r⇧*" and "(u,z) ∈ r" and "(u,y) ∈ (r¯)⇧*"
show "(z,y) ∈ (r¯)⇧*"
proof (rule rtrancl_trans)
show "(z,u) ∈ (r¯)⇧*" using `(u,z) ∈ r` by auto
next
show "(u,y) ∈ (r¯)⇧*" using `(u,y) ∈ (r¯)⇧*` by simp
qed
qed

-- "La demostración detalla del teorema es"
theorem cl_rtrans_inversa:
"(r¯)⇧* = (r⇧*)¯"
proof
show "(r¯)⇧* ⊆ (r⇧*)¯" by (auto simp add:cl_rtrans_inversaD)
next
show "(r⇧*)¯ ⊆ (r¯)⇧*" by (auto simp add:cl_rtrans_inversaI)
qed

-- "La demostración automática del teorema es"
theorem "(r¯)⇧* = (r⇧*)¯"
by (auto intro: cl_rtrans_inversaI dest: cl_rtrans_inversaD)

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

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

La relación-objeto "less_than" es el orden de los naturales definido
por
· less_than = pred_nat^+
donde pred_nat está definida por
· pred_nat = {(m, n). n = Suc m}

La caracterización de less_than es
· less_than_iff: ((x,y) ∈ less_than) = (x < y)

La relación less_than está bien fundamentada
· wf_less_than: wf less_than

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

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

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

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

section {* Puntos fijos *}

text {*
La teoría de los puntos fijos se aplican a las funciones monótonas.

Las funciones monótonas está definida (en Orderings.thy) por
· mono_def: mono f ≡ ∀A B. A ≤ B ⟶ f A ≤ f B

Las reglas de introducción y eliminación de la monotonicidad son:
. monoI: (⋀A B. A ≤ B ⟹ f A ≤ f B) ⟹ mono f
· monoD: ⟦mono f ⟹ A ≤ B⟧ ⟹ f A ≤ f B

El menor punto fijo de un operador está definido en la teoría
Inductive.thy, para los retículos completos, por
· lfp_def: lfp f = Inf {u. f u ≤ u}

El menor punto fijo de una función monótona es un punto fijo:
· lfp_unfold: mono f ⟹ lfp f = f (lfp f)

La regla de inducción del menor punto fijo es
· lfp_induct_set: ⟦ a ∈ lfp(f);
mono(f);
⋀x. ⟦ x ∈ f(lfp(f) ⋂ {x. P(x)}) ⟧ ⟹ P(x) ⟧
⟹ P(a)
*}

text {*
El mayor punto fijo de un operador está definido en la teoría
Inductive.thy, para los retículos completos, por
· gfp_def: gfp f = Sup {u. u ≤ f u}

El menor punto fijo de una función monótona es un punto fijo:
· gfp_unfold: mono f ⟹ gfp f = f (gfp f)

La regla de inducción del menor punto fijo es
· coinduct_set: ⟦ mono(f);
a ∈ X;
X ⊆ f(X ⋃ gfp(f)) ⟧
⟹ a ∈ gfp(f)
*}

end
</source>

Tema 9: Conjuntos, funciones y relaciones

2015-01-06T12:41:38Z

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

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

theory T9_Conjuntos_funciones_y_relaciones
imports Main
begin

section {* Conjuntos *}

subsection {* Operaciones con conjuntos *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

subsection {* Notación de conjuntos finitos *}

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

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

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

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

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

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

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

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

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

text {*
Ejemplo con la conjetura corregida.
*}

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

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

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

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

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

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

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

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

declare sumaConj_def[simp]
declare sumaCuadradosConj_def[simp]

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

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

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

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

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

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

subsection {* Definiciones por comprensión *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- "La demostración detallada es"
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" by (rule IntD1)
hence "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" by (rule IntD2)
hence "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

-- "La demostración estructurada es"
lemma "x ∉ (Pares ∩ Impares)"
proof
fix x assume S: "x ∈ (Pares ∩ Impares)"
hence "x ∈ Pares" ..
hence "∃m. x = 2 * m" by (simp only: Pares_def mem_Collect_eq)
then obtain p where p: "x = 2 * p" ..
from S have "x ∈ Impares" ..
hence "∃ m. x = 2 * m + 1" by (simp only: Impares_def mem_Collect_eq)
then obtain q where q: "x = 2 * q + 1" ..
from p and q show "False" by arith
qed

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

subsection {* Cuantificadores acotados *}

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

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

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

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

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

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

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

subsection {* Conjuntos finitos y cardinalidad *}

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

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

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

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

section {* Funciones *}

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

subsection {* Nociones básicas de funciones *}

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

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

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

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

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

subsection {* Funciones inyectivas, suprayectivas y biyectivas *}

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

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

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

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

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

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

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

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

-- "La demostración estructurada es"
lemma
assumes "inj f"
shows "(f ∘ g = f ∘ h) = (g = h)"
proof
assume "f ∘ g = f ∘ h"
thus "g = h" using `inj f` by (simp add: inj_on_def fun_eq_iff)
next
assume "g = h"
thus "f ∘ g = f ∘ h" by auto
qed

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

subsubsection {* Función imagen *}

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

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

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

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

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

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

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

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

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

section {* Relaciones *}

subsection {* Relaciones básicas *}

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

Las relaciones son conjuntos de pares.

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

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

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

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

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

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

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

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

subsection {* Clausura reflexiva y transitiva *}

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

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

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

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

Inducción sobre la clausura reflexiva y transitiva
· rtrancl_induct: ⟦(a,b) ∈ r⇧*;
P b;
⋀y z. ⟦(y,z) ∈ r; (z,b) ∈ r⇧*; P z⟧ ⟹ P y⟧
⟹ P a

Idempotencia de la clausura reflexiva y transitiva:
· rtrancl_idemp: (r⇧* )⇧* = r⇧*

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

Ejemplo de propiedad:
· trancl_converse: (r¯)⇧+ = (r⇧+)¯
*}

subsection {* Una demostración elemental *}

text {*
Se desea demostrar que la clausura reflexiva y transitiva conmuta con
la inversa (cl_rtrans_inversa).
*}

theorem "(r¯)⇧* = (r⇧*)¯"
oops

text {* Para demostrarlo introducimos dos lemas auxiliares:
cl_rtrans_inversaD y cl_rtrans_inversaI.
*}

-- "La demostración detallada del primer lema es"
lemma cl_rtrans_inversaD:
"(x,y) ∈ (r¯)⇧* ⟹ (y,x) ∈ r⇧*"
proof (induct rule:rtrancl_induct)
show "(x,x) ∈ r⇧*" by (rule rtrancl_refl)
next
fix y z
assume "(x,y) ∈ (r¯)⇧*" and "(y,z) ∈ r¯" and "(y,x) ∈ r⇧*"
show "(z,x) ∈ r⇧*"
proof (rule rtrancl_trans)
show "(z,y) ∈ r⇧*" using `(y,z) ∈ r¯` by simp
next
show "(y,x) ∈ r⇧*" using `(y,x) ∈ r⇧*` by simp
qed
qed

-- "La demostración automática del primer lema es"
lemma cl_rtrans_inversaD2:
"(x,y) ∈ (r¯)⇧* ⟹ (y,x) ∈ r⇧*"
by (induct rule: rtrancl_induct)
(auto simp add: rtrancl_trans)

-- "La demostración detallada del segundo lema es"
lemma cl_rtrans_inversaI:
"(y,x) ∈ r⇧* ⟹ (x,y) ∈ (r¯)⇧*"
proof (induct rule: rtrancl_induct)
show "(y,y) ∈ (r¯)⇧*" by (rule rtrancl_refl)
next
fix u z
assume "(y,u) ∈ r⇧*" and "(u,z) ∈ r" and "(u,y) ∈ (r¯)⇧*"
show "(z,y) ∈ (r¯)⇧*"
proof (rule rtrancl_trans)
show "(z,u) ∈ (r¯)⇧*" using `(u,z) ∈ r` by auto
next
show "(u,y) ∈ (r¯)⇧*" using `(u,y) ∈ (r¯)⇧*` by simp
qed
qed

-- "La demostración detalla del teorema es"
theorem cl_rtrans_inversa:
"(r¯)⇧* = (r⇧*)¯"
proof
show "(r¯)⇧* ⊆ (r⇧*)¯" by (auto simp add:cl_rtrans_inversaD)
next
show "(r⇧*)¯ ⊆ (r¯)⇧*" by (auto simp add:cl_rtrans_inversaI)
qed

-- "La demostración automática del teorema es"
theorem "(r¯)⇧* = (r⇧*)¯"
by (auto intro: cl_rtrans_inversaI dest: cl_rtrans_inversaD)

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

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

La relación-objeto "less_than" es el orden de los naturales definido
por
· less_than = pred_nat^+
donde pred_nat está definida por
· pred_nat = {(m, n). n = Suc m}

La caracterización de less_than es
· less_than_iff: ((x,y) ∈ less_than) = (x < y)

La relación less_than está bien fundamentada
· wf_less_than: wf less_than

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

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

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

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

section {* Puntos fijos *}

text {*
La teoría de los puntos fijos se aplican a las funciones monótonas.

Las funciones monótonas está definida (en Orderings.thy) por
· mono_def: mono f ≡ ∀A B. A ≤ B ⟶ f A ≤ f B

Las reglas de introducción y eliminación de la monotonicidad son:
. monoI: (⋀A B. A ≤ B ⟹ f A ≤ f B) ⟹ mono f
· monoD: ⟦mono f ⟹ A ≤ B⟧ ⟹ f A ≤ f B

El menor punto fijo de un operador está definido en la teoría
Inductive.thy, para los retículos completos, por
· lfp_def: lfp f = Inf {u. f u ≤ u}

El menor punto fijo de una función monótona es un punto fijo:
· lfp_unfold: mono f ⟹ lfp f = f (lfp f)

La regla de inducción del menor punto fijo es
· lfp_induct_set: ⟦ a ∈ lfp(f);
mono(f);
⋀x. ⟦ x ∈ f(lfp(f) ⋂ {x. P(x)}) ⟧ ⟹ P(x) ⟧
⟹ P(a)
*}

text {*
El mayor punto fijo de un operador está definido en la teoría
Inductive.thy, para los retículos completos, por
· gfp_def: gfp f = Sup {u. u ≤ f u}

El menor punto fijo de una función monótona es un punto fijo:
· gfp_unfold: mono f ⟹ gfp f = f (gfp f)

La regla de inducción del menor punto fijo es
· coinduct_set: ⟦ mono(f);
a ∈ X;
X ⊆ f(X ⋃ gfp(f)) ⟧
⟹ a ∈ gfp(f)
*}

end
</source>

Temas

2015-01-06T12:40:33Z

Jalonso:

Relación 8

2014-12-18T12:09:38Z

Jalonso:

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

theory R8
imports Main
begin

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

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H)"

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

-- "javrodviv1, jeshorcob, davoremar, domcadgom, carvelcab, juacorvic"
fun hojas :: "arbol => nat" where
"hojas H = 1"
| "hojas (N i d) = hojas i + hojas d"

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

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

-- "javrodviv1"
fun max :: "nat ⇒ nat ⇒ nat" where
"max a b = (if a≥ b then a else b)"

value "max 6 3" -- "= 6"

-- "davoremar, carvelcab, juacorvic"
fun profundidad :: "arbol => nat" where
"profundidad H = 0"
| "profundidad (N a b) = 1 + max (profundidad a) (profundidad b)"

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

(* Javrodviv1: Explico estas dos funciones, la que utilizo para los
lemas de abajo es profundidad ya que profundidad1 me encuentra
contraejemplos y para evitar eso busque definir profundidad
definidad de manera distinta. No obstante la que a mi me parece
mas sensata para definir la profundidad de un árbol es la
profundidad1 *)

(* Javrodviv1: Fallo mio ya lo corregí *)

(* Pedrosrei: La profundidad correcta es la mayor. Si te encuentra
contraejemplos más adelante es que te has equivocado en los
enunciados. Las funciones máximo y mínimo vienen predefinidas
ya sin necesidad de definirlas. *)

-- "jeshorcob, domcadgom"
fun pr1 :: "arbol => nat" where
"pr1 H = 0"
| "pr1 (N i d) = Suc (max (pr1 i) (pr1 d))"

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

-- "javrodviv1, jeshorcob, davoremar, domcadgom, carvelcab, juacorvic"
fun abc :: "nat ⇒ arbol" where
"abc 0 = H"
| "abc (Suc n) = N (abc n) (abc n)"

-- "jeshorcob" (* ¿Pudiera ser que esta sea más rápida? *)
fun abc1 :: "nat ⇒ arbol" where
"abc1 0 = H"
| "abc1 (Suc n) = (let a = abc1 n in N a a)"

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

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

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

-- "javrodviv1"
fun es_abc1 :: "(arbol => 'a) => arbol => bool" where
"es_abc1 f H = True"
| "es_abc1 f (N a b) = ((f a = f b) ∧ (es_abc1 f a ∧ es_abc1 f b))"

-- "jeshorcob, davoremar, domcadgom, carvelcab"
fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc f H = True"
| "es_abc f (N i d) = (f i = f d ∧ es_abc f i ∧ es_abc f d)"

-- "juacorvic"
fun es_abc3 :: "(arbol => 'a) => arbol => bool" where
"es_abc3 f H = True"
| "es_abc3 f (N i d) = ( es_abc3 f i ∧ es_abc3 f d ∧ f i = f d )"

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

(* Para entenderme he cambiado de función de tamaño, la demostración
es análoga pero buscando las simplificaciones de size cuando
correspondan *)

fun nodos::"arbol ⇒ nat" where
"nodos H = 0"
| "nodos (N i d) = 1 + (nodos i) + (nodos d)"

lemma "size t = nodos t"
apply (induct t, auto)done

value "size (N (N H H) (N H H))"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"

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

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

(* Pedrosrei: Los enunciados y demostraciones que vienen a continuación
son feos y engorrosos. Yo he optado por demostrarlo todo a través de
una propiedad extraña a la demostración en principio. Animo
encarecidamente a que pongáis una demostración más corta y directa.
Voy explicando paso a paso qué he hecho en cada momento. Hecha esta
demostración, el resto son triviales por una cadena de resultados.

No existe relación de implicación en ningún sentido entre hojas y
profundidad, como es obvio y muestran los siguientes contraejemplos:
*)

lemma "hojas t1 = hojas t2 ⟶ profundidad t1 = profundidad t2"
quickcheck
oops

lemma "profundidad t1 = profundidad t2 ⟶ hojas t1 = hojas t2"
quickcheck
oops

lemma "profundidad t1 = profundidad t2 ⟷ hojas t1 = hojas t2"
quickcheck
oops

(* Quickchecking...
Testing conjecture with Quickcheck-exhaustive...
Quickcheck found a counterexample:

t1 = N (N H H) (N H H)
t2 = N H (N H H)

Evaluated terms:
hojas t1 = 4
hojas t2 = 3

Ahora pongo una serie de resultados auxiliares que ayudarán en la prueba
*)

lemma auxprof: "es_abc profundidad t ∧ profundidad t = n ⟹ t = abc n"
apply (induct t arbitrary:n, auto)
done

lemma eq_1_iff_exp_0: "Suc 0 = 2^n ⟷ n = 0"
apply (cases n, auto)
done

lemma auxhojas: "t = abc n ⟹ es_abc hojas t"
apply (induct n arbitrary: t, auto simp add: eq_1_iff_exp_0)
done

lemma auxhoja: "t = abc n ⟹ hojas t = 2^n"
apply (induct n arbitrary: t rule: abc.induct, auto)
done

(* Pedrosrei. Y aquí viene la demostración larga y fea que os animo a
mejorar. He dejado los pasos exactamente que indica el razonador para
que veáis qué hace en cada caso: *)

lemma prof_eq_hoja: "es_abc profundidad t ⟷ es_abc hojas t"
proof
assume a1: "es_abc profundidad t"
have "∀t. ∃n. n = profundidad t" by auto
then obtain n where "n = profundidad t" by auto
with a1 have 1: "t= abc n" using auxprof by auto
thus "es_abc hojas t" using auxhojas by auto
next
show "es_abc hojas t ⟹ es_abc profundidad t"
apply (induct t, auto)
proof -
fix t1 t2
assume a1: "es_abc profundidad t1"
thus "es_abc profundidad t2 ⟹
es_abc hojas t1 ⟹
es_abc hojas t2 ⟹
hojas t1 = hojas t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a2: "es_abc profundidad t2"
thus "es_abc hojas t1 ⟹
es_abc hojas t2 ⟹
hojas t1 = hojas t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a3: "es_abc hojas t1"
thus "es_abc hojas t2 ⟹
hojas t1 = hojas t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a4:"es_abc hojas t2"
thus "hojas t1 = hojas t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a5: "hojas t1 = hojas t2"
thus "profundidad t1 = profundidad t2"
proof -
obtain n where 1:" profundidad t1 = n" by auto
with a1 have 2: "t1 = abc n" using auxprof by auto
hence 3: "es_abc hojas t1" using auxhojas by auto
have "hojas t1 = (2::nat)^n" using 2 auxhoja by auto
hence 3:"hojas t2 = (2::nat)^n" using a5 by auto
obtain m where 4: "profundidad t2 = m" by auto
with a2 have 5: "t2 = abc m" using auxprof by auto
hence 6: "es_abc hojas t2" using auxhojas by auto
have "hojas t2 = (2::nat)^m" using 5 auxhoja by auto
with 3 have " (2::nat)^m = (2::nat) ^n" by auto
hence "m = n" apply (induct, auto) done
hence "t2 = abc n" using 5 by auto
with 2 have "t1= t2" by auto
thus "profundidad t1 = profundidad t2" by auto
qed
qed
qed
qed
qed
qed
qed

(* jeshorcob: creo que tengo una demostración mas elegante tan
sólo hace falta encontrar la relacion entre hojas y profundidad. *)

-- "jeshorcob, carvelcab"
lemma a1:
assumes "es_abc hojas a"
shows "hojas a = 2^(pr1 a)"
using assms
by (induct a, simp_all)

-- "jeshorcob, carvelcab"
lemma cpr1_chojas: "es_abc pr1 a = es_abc hojas a"
by (induct a, auto simp add: a1)

(* mjeshorcob: esta es la detallada*)
-- "jeshorcob,caarvelcab"
lemma "es_abc pr1 a = es_abc hojas a" (is "?P a")
proof (induct a)
show "?P H" by simp
next
fix i d
assume h1: "?P i"
assume h2: "?P d"
have "es_abc pr1 (N i d) =
(pr1 i = pr1 d ∧ es_abc pr1 i ∧ es_abc pr1 d )" by simp
also have "… = (pr1 i = pr1 d ∧ es_abc hojas i ∧ es_abc hojas d)"
using h1 and h2 by simp
also have "… = (hojas i = hojas d ∧ es_abc hojas i ∧ es_abc hojas d)"
using a1 by auto
also have "… = es_abc hojas (N i d)" by simp
finally show "?P (N i d)" by simp
qed

-- "domcadgom"
lemma aux1: "es_abc profundidad a ⟹ hojas a = 2^(profundidad a)"
by (induct a, simp_all)

lemma completo1: "es_abc (profundidad) a = es_abc (hojas) a"
proof (induct a, simp)
fix a1 :: arbol and a2 :: arbol
assume a1: "es_abc profundidad a1 = es_abc hojas a1"
assume a2: "es_abc profundidad a2 = es_abc hojas a2"
have "es_abc profundidad a2 ∧ es_abc profundidad a1 ⟶
es_abc profundidad (N a1 a2) = es_abc hojas (N a1 a2)"
using a1 a2 by (simp add: aux1)
thus "es_abc profundidad (N a1 a2) = es_abc hojas (N a1 a2)"
using a1 a2 es_abc.simps(2) by blast
qed

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

(* Javrodviv1: Bueno yo para este ejercicio he encontrado algo más
sencillo, tan sólo hay que encontrar una relación de igualdad entre
hojas y size, que para este caso es sencillo.*)

-- "Javrodviv1,carvelcab"
lemma hojasize_igualdad: "hojas x = size x + 1"
by (induct x, simp_all)

(* lemma "es_abc size a <-> es_abc hojas a" Son equivalentes = es lo
mismo que ⟷ matemáticamente hablando*)

lemma "es_abc size a = es_abc hojas a"
by (induct a, simp_all add: hojasize_igualdad)

(* Pedrosrei. Aquí dejo esta. Es trivial debido a la demostración
anterior, sólo hace falta coger el mismo desvío. Aquí sí que podéis
encontrar una mucho más directa: *)

lemma auxnodo: "t = abc n ⟹ es_abc nodos t ∧ nodos t = (2^n - 1)"
apply (induct n arbitrary: t rule: abc.induct, auto)
done

lemma nodos_eq_hoja: "es_abc nodos t ⟷ es_abc hojas t" (is "?P t")
proof -
have 1:"es_abc hojas t ⟷ es_abc profundidad t"
using prof_eq_hoja by auto
hence 2:"?P t = (es_abc profundidad t ⟷ es_abc nodos t)" by auto
have "es_abc profundidad t ⟷ es_abc nodos t"
proof
assume a1: "es_abc profundidad t"
have "∀t. ∃n. n = profundidad t" by auto
then obtain n where "n = profundidad t" by auto
with a1 have 1:"t= abc n" using auxprof by auto
thus "es_abc nodos t" using auxnodo by auto
next
show "es_abc nodos t ⟹ es_abc profundidad t"
apply (induct t, auto)
proof -
fix t1 t2
assume a1: "es_abc profundidad t1"
thus "es_abc profundidad t2 ⟹
es_abc nodos t1 ⟹
es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a2: "es_abc profundidad t2"
thus "es_abc nodos t1 ⟹
es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof-
assume a3: "es_abc nodos t1"
thus "es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof-
assume a4: "es_abc nodos t2"
thus "nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a5: "nodos t1 = nodos t2"
thus "profundidad t1 = profundidad t2"
proof -
obtain n where 1: "profundidad t1 = n" by auto
with a1 have 2: "t1 = abc n" using auxprof by auto
hence 3: "es_abc nodos t1" using auxnodo by auto
have "nodos t1 = (2::nat)^n - 1"
using 2 auxnodo by auto
hence 3:"nodos t2 = (2::nat)^n - 1" using a5 by auto
obtain m where 4: "profundidad t2 = m" by auto
with a2 have 5:"t2 = abc m"using auxprof by auto
hence 6:"es_abc nodos t2" using auxnodo by auto
have "nodos t2 = (2::nat)^m - 1"
using 5 auxnodo by auto
with 3 have 7: "(2::nat)^m - 1 = (2::nat) ^n - 1"
by auto
hence "m = n"
proof -
have " (2::nat)^m - 1 = (2::nat) ^n - 1"
using 7 by auto
hence "(2::nat)^m - 1 + 1 = (2::nat) ^n" by auto
hence "(2::nat)^m = (2::nat) ^n" by auto
thus ?thesis apply (induct, auto)done
qed
hence "t2 = abc n" using 5 by auto
with 2 have "t1= t2" by auto
thus "profundidad t1 = profundidad t2" by auto
qed
qed
qed
qed
qed
qed
qed
with 1 2 show ?thesis by auto
qed

(* jeshorcob: aquí similar*)

-- "jeshorcob"
lemma a2:
assumes "es_abc size a"
shows "hojas a = (size a) + 1"
using assms
by (induct a, simp_all)

-- "jeshorcob"
lemma chojas_cnodos: "es_abc hojas a = es_abc size a"
by (induct a, auto simp add: a2)

-- "jeshorcob"
lemma "es_abc hojas a = es_abc size a" (is "?P a")
proof (induct a)
show "?P H" by simp
next
fix i d
assume h1: "?P i"
assume h2: "?P d"
have "es_abc hojas (N i d) =
(hojas i = hojas d ∧ es_abc hojas i ∧ es_abc hojas d )" by simp
also have "… = (hojas i = hojas d ∧ es_abc size i ∧ es_abc size d)"
using h1 and h2 by simp
also have "... = (size i = size d ∧ es_abc size i ∧ es_abc size d)"
using a2 by auto
also have "... = es_abc size (N i d)" by simp
finally show "?P (N i d)" by simp
qed

--"domcadgom"

lemma aux2: "es_abc size a ⟹ (hojas a = size a + 1)"
by (induct a, simp_all)

lemma completo2: "es_abc hojas a = es_abc (size) a"
proof (induct a, simp)
fix a1 :: arbol and a2 :: arbol
assume a1: "es_abc hojas a1 = es_abc size a1"
assume a2: "es_abc hojas a2 = es_abc size a2"
hence "es_abc size a2 ∧ es_abc size a1 ⟶
es_abc hojas (N a1 a2) = es_abc size (N a1 a2)"
using a1 by (simp add: aux2)
thus "es_abc hojas (N a1 a2) = es_abc size (N a1 a2)"
using a1 a2 es_abc.simps(2) by blast
qed

-- "juacorvic"
(* número de hojas es size + 1 *)
lemma l_hojas_size: "hojas x = size x + 1"
proof (induct x)
show " hojas H = size H + 1" by simp
next
fix x1 x2
assume h1: "hojas x1 = size x1 + 1"
assume h2:"hojas x2 = size x2 + 1"
have "hojas (N x1 x2) = hojas x1 + hojas x2" by simp
also have "... = size x1 + 1 + size x2 + 1" using h1 h2 by simp
also have "... = (1 + size x1 + size x2) + 1" by simp
also have "... = size (N x1 x2) + 1" by simp
finally show "hojas (N x1 x2) = size (N x1 x2) + 1" by simp
qed

-- "juacorvic"
(* usando lema anterior *)
lemma rel_size_igualdad: " es_abc size a = es_abc hojas a"
by (induct a, simp_all add: l_hojas_size)

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

(* Pedrosrei. De hecho, esta es una parte de la anterior: *)

lemma prof_eq_nodos: "es_abc profundidad t ⟷ es_abc nodos t"
proof
assume a1: "es_abc profundidad t"
have "∀t. ∃n. n = profundidad t" by auto
then obtain n where "n = profundidad t" by auto
with a1 have 1:"t= abc n" using auxprof by auto
thus "es_abc nodos t" using auxnodo by auto
next
show "es_abc nodos t ⟹ es_abc profundidad t"
apply (induct t, auto)
proof -
fix t1 t2
assume a1: "es_abc profundidad t1"
thus "es_abc profundidad t2 ⟹
es_abc nodos t1 ⟹
es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a2: "es_abc profundidad t2"
thus "es_abc nodos t1 ⟹
es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof-
assume a3: "es_abc nodos t1"
thus "es_abc nodos t2 ⟹
nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof-
assume a4: "es_abc nodos t2"
thus "nodos t1 = nodos t2 ⟹
profundidad t1 = profundidad t2"
proof -
assume a5: "nodos t1 = nodos t2"
thus "profundidad t1 = profundidad t2"
proof -
obtain n where 1:"profundidad t1 = n" by auto
with a1 have 2:"t1 = abc n"using auxprof by auto
hence 3:"es_abc nodos t1" using auxnodo by auto
have "nodos t1 = (2::nat)^n - 1" using 2 auxnodo by auto
hence 3:"nodos t2 = (2::nat)^n - 1" using a5 by auto
obtain m where 4:"profundidad t2 = m" by auto
with a2 have 5:"t2 = abc m"using auxprof by auto
hence 6:"es_abc nodos t2" using auxnodo by auto
have "nodos t2 = (2::nat)^m - 1" using 5 auxnodo by auto
with 3 have 7:" (2::nat)^m - 1 = (2::nat) ^n - 1" by auto
hence "m = n"
proof -
have " (2::nat)^m - 1 = (2::nat) ^n - 1"using 7 by auto
hence "(2::nat)^m - 1 + 1 = (2::nat) ^n" by auto
hence "(2::nat)^m = (2::nat) ^n" by auto
thus ?thesis apply (induct, auto)done
qed
hence "t2 = abc n" using 5 by auto
with 2 have "t1= t2" by auto
thus "profundidad t1 = profundidad t2" by auto
qed
qed
qed
qed
qed
qed
qed

(*jeshorcob: sale directo como corolario de los anteriores*)

--"jeshorcob,carvelcab"
lemma "es_abc pr1 a = es_abc size a"
using cpr1_chojas and chojas_cnodos by simp_all

-- "domcadgom"
corollary completo3: "es_abc profundidad a = es_abc size a"
using completo1 completo2 by simp

--"juacorvic"
(* 1.- En apartado 7 se demuestra que:
es_abc profundidad a ⟷ es_abc hojas a
2.- En apartado 8 se demuestra que:
es_abc hojas a ⟷ es_abc size a
3.- Luego podremos demostrar usando las anteriores:
es_abc profundidad a ⟷ es_abc size a

Nota: Aplico demostración de "domcadgom" de apartado 7, que no he
conseguido reproducir *)

lemma "es_abc profundidad a = es_abc size a"
using completo1 rel_size_igualdad by simp_all

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

-- "Pedrosrei"
lemma " es_abc f (abc n)"
apply (induct n, auto)
done

-- "jeshorcob, davoremar, domcadgom, carvelcab, juacorvic"
lemma "es_abc f (abc n)"
by (induct n, simp_all)

-- "jeshorcob"
lemma "es_abc f (abc n)" (is "?P n")
proof (induct n)
show "?P 0" by simp
next
fix n assume h: "?P n"
have "es_abc f (abc (Suc n)) = es_abc f (N (abc n) (abc n))" by simp
also have "... = (f (abc n) = f (abc n) ∧
es_abc f (abc n) ∧ es_abc f (abc n))" by simp
also have "... = True" using h by simp
finally show "?P (Suc n)" by simp
qed

-- "juacorvic"
(* Más detallada *)
lemma "es_abc f (abc n)"
proof (induct n)
show " es_abc f (abc 0)" by simp
next
fix n
assume h1: "es_abc f (abc n)"
have "es_abc f (abc (Suc n)) = es_abc f (N (abc n) (abc n))" by simp
also have "... = (es_abc f (abc n) ∧ es_abc f (abc n) ∧
(f (abc n) = f (abc n)))" by simp
also have "... = (f (abc n) = f (abc n) )" using h1 by simp
also have "... = True " by simp
finally show "es_abc f (abc n) ⟹ es_abc f (abc (Suc n))" by simp
qed

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es (abc (profundidad a)).
---------------------------------------------------------------------
*}

--"Pedrosrei:"
lemma "es_abc profundidad a ⟹ (a = abc (profundidad a))"
apply (induct a, auto)
done

-- "jeshorcob"
lemma "es_abc pr1 a ⟹ (a = abc (pr1 a))"
by (induct a, simp_all)

--"davoremar, domcadgom"
lemma "es_abc profundidad a ⟹ (a = abc (profundidad a))"
by (induct a, simp_all)

--"juacorvic"
lemma "es_abc profundidad a ⟹ a = abc (profundidad a)"
by (induct a, simp_all)

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

--"Pedrosrei:"
lemma "es_abc f = es_abc nodos"
quickcheck
oops

(*
El contraejemplo no es más que una medida constante, la trivial:

Quickchecking...
Testing conjecture with Quickcheck-exhaustive...
Quickcheck found a counterexample:

f = λx. a⇣1
x = N H (N H H)

Evaluated terms:
es_abc f x = True
es_abc R8_Arboles_binarios_completos.size x = False
*)

(* jeshorcob: usando size en lugar de nodos, se encuentra el mismo
contraejemplo. *)
--"jeshorcob, domcadgom"
lemma "es_abc f = es_abc size"
quickcheck
oops

(*
el contraejemplo es:

f = λx. a⇩1
x = N H (N H H)

Evaluated terms:
es_abc f x = True
es_abc size x = False
*)

-- "davoremar"
lemma "es_abc f t = es_abc size t"
quickcheck
oops

-- "juacorvic"
fun medida :: "arbol => nat" where
"medida H = 0"
| "medida (N i d) = 0"

lemma "es_abc medida a = es_abc size a"
quickcheck
oops

(*Contraejemplo
value "es_abc medida (N H (N H H))" (*devuelve true*)
value "es_abc size (N H (N H H))" (*devuelve false*)
*)

end
</source>

Relación 10

2014-12-18T10:13:31Z

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

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

theory R10
imports Main
begin

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

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

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si no está el mañana ni el ayer escrito, entonces no está el mañana
escrito.
Usar M: El mañana está escrito.
A: El ayer está escrito.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y demostrar la corrección, del siguiente
argumento
Siempre que un número x es divisible por 10, acaba en 0. El número
x no acaba en 0. Por lo tanto, x no es divisible por 10.
Usar D para "el número es divisible por 10" y
C para "el número acaba en cero".
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y demostrar la corrección, del siguiente
argumento
Si no hay control de nacimientos, entonces la población crece
ilimitadamente; pero si la población crece ilimitadamente,
aumentará el índice de pobreza. Por consiguiente, si no hay control
de nacimientos, aumentará el índice de pobreza.
Usar N: Hay control de nacimientos.
P: La población crece ilimitadamente,
I: Aumentará el índice de pobreza.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y demostrar la corrección, del siguiente
argumento
Si te llamé por teléfono, entonces recibiste mi llamada y no es
cierto que no te avisé del peligro que corrías. Por consiguiente,
como te llamé, es cierto que te avisé del peligro que corrías.
Usar T: Te llamé por teléfono.
R: Recibiste mi llamada.
P: Te avisé del peligro que corrías.
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 6. Formalizar, y demostrar la corrección, del siguiente
argumento
Cuando tanto la temperatura como la presión atmosférica permanecen
contantes, no llueve. La temperatura permanece constante. Por lo
tanto, en caso de que llueva, la presión atmosférica no permanece
constante.
Usar T para "La temperatura permanece constante",
P para "La presión atmosférica permanece constante" y
L para "Llueve".
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 7. Formalizar, y demostrar la corrección, del siguiente
argumento
Si el general era leal, hubiera obedecido las órdenes, y si era
inteligente las hubiera comprendido. O el general desobedeció las
órdenes o no las comprendió. Luego, el general era desleal o no era
inteligente.
Usar L: El general es leal.
Ob: El general obedece las órdenes.
I: El general es inteligente.
C: El general comprende las órdenes.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 8. Formalizar, y demostrar la corrección, del siguiente
argumento
Me matan si no trabajo y si trabajo me matan. Me matan siempre me
matan.
Usar M: Me matan.
T: Trabajo.
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 10. Formalizar, y demostrar la corrección, del siguiente
argumento
Si trabajo gano dinero, pero si no trabajo gozo de la vida. Sin
embargo, si trabajo no gozo de la vida, mientras que si no trabajo
no gano dinero. Por lo tanto, gozo de la vida si y sólo si no gano
dinero.
Usar p: Trabajo
q: Gano dinero.
r: Gozo de la vida.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 11. Formalizar, y demostrar la corrección, del siguiente
argumento
Si Dios fuera capaz de evitar el mal y quisiera hacerlo, lo
haría. Si Dios fuera incapaz de evitar el mal, no sería
omnipotente; si no quisiera evitar el mal sería malévolo. Dios no
evita el mal. Si Dios existe, es omnipotente y no es
malévolo. Luego, Dios no existe.
Usar C: Dios es capaz de evitar el mal.
Q: Dios quiere evitar el mal.
Om: Dios es omnipotente.
M: Dios es malévolo.
P: Dios evita el mal.
E: Dios existe.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 12. Formalizar, y decidir la corrección, del siguiente
argumento
Sócrates es un hombre.
Los hombres son mortales.
Luego, Sócrates es mortal.
Usar s para Sócrates
H(x) para x es un hombre
M(x) para x es mortal
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 14. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los participantes son vencedores. Hay como máximo un
vencedor. Hay como máximo un participante. Por lo tanto, hay
exactamente un participante.
Usar P(x) para x es un participante
V(x) para x es un vencedor
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 15. Formalizar, y decidir la corrección, del siguiente
argumento
Todo aquel que entre en el país y no sea un VIP será cacheado por
un aduanero. Hay un contrabandista que entra en el país y que solo
podrá ser cacheado por contrabandistas. Ningún contrabandista es un
VIP. Por tanto, algún aduanero es contrabandista.
Usar A(x) para x es aduanero
Ca(x,y) para x cachea a y
Co(x) para x es contrabandista
E(x) para x entra en el pais
V(x) para x es un VIP
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 16. Formalizar, y decidir la corrección, del siguiente
argumento
Juan teme a María. Pedro es temido por Juan. Luego, alguien teme a
María y a Pedro.
Usar j para Juan
m para María
p para Pedro
T(x,y) para x teme a y
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 18. Formalizar, y decidir la corrección, del siguiente
argumento
La existencia de algún canal de TV pública, supone un acicate para
cualquier canal de TV privada; el que un canal de TV tenga un
acicate, supone una gran satisfacción para cualquiera de sus
directivos; en Madrid hay varios canales públicos de TV; TV5 es un
canal de TV privada; por tanto, todos los directivos de TV5 están
satisfechos.
Usar Pu(x) para x es un canal de TV pública
Pr(x) para x es un canal de TV privada
A(x) para x posee un acicate
D(x,y) para x es un directivo del canal y
S(x) para x está satisfecho
t para TV5
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 19. Formalizar, y decidir la corrección, del siguiente
argumento
Quien intente entrar en un país y no tenga pasaporte, encontrará
algún aduanero que le impida el paso. A algunas personas
motorizadas que intentan entrar en un país le impiden el paso
únicamente personas motorizadas. Ninguna persona motorizada tiene
pasaporte. Por tanto, ciertos aduaneros están motorizados.
Usar E(x) para x entra en un país
P(x) para x tiene pasaporte
A(x) para x es aduanero
I(x,y) para x impide el paso a y
M(x) para x está motorizada
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 21. Formalizar, y decidir la corrección, del siguiente
argumento
Ningún aristócrata debe ser condenado a galeras a menos que sus
crímenes sean vergonzosos y lleve una vida licenciosa. En la ciudad
hay aristócratas que han cometido crímenes vergonzosos aunque su
forma de vida no sea licenciosa. Por tanto, hay algún aristócrata
que no está condenado a galeras.
Usar A(x) para x es aristócrata
G(x) para x está condenado a galeras
L(x) para x lleva una vida licenciosa
V(x) para x ha cometido crímenes vergonzoso
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 22. Formalizar, y decidir la corrección, del siguiente
argumento
Todo individuo que esté conforme con el contenido de cualquier
acuerdo internacional lo apoya o se inhibe en absoluto de asuntos
políticos. Cualquiera que se inhiba de los asuntos políticos, no
participará en el próximo referéndum. Todo español, está conforme
con el acuerdo internacional de Maastricht, al que sin embargo no
apoya. Por tanto, cualquier individuo o no es español, o en otro
caso, está conforme con el contenido del acuerdo internacional de
Maastricht y no participará en el próximo referéndum.
Usar C(x,y) para la persona x conforme con el contenido del acuerdo y
A(x,y) para la persona x apoya el acuerdo y
I(x) para la persona x se inibe de asuntos políticos
R(x) para la persona x participará en el próximo referéndum
E(x) para la persona x es española
m para el acuerdo de Maastricht
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 24. Formalizar, y decidir la corrección, del siguiente
argumento
Todo deprimido que estima a un submarinista es listo. Cualquiera
que se estime a sí mismo es listo. Ningún deprimido se estima a sí
mismo. Por tanto, ningún deprimido estima a un submarinista.
Usar D(x) para x está deprimido
E(x,y) para x estima a y
L(x) para x es listo
S(x) para x es submarinista
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 25. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los robots obedecen a los amigos del programador jefe.
Alvaro es amigo del programador jefe, pero Benito no le
obedece. Por tanto, Benito no es un robot.
Usar R(x) para x es un robot
Ob(x,y) para x obedece a y
A(x) para x es amigo del programador jefe
b para Benito
a para Alvaro
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 26. Formalizar, y decidir la corrección, del siguiente
argumento
En una pecera nadan una serie de peces. Se observa que:
* Hay algún pez x que para cualquier pez y, si el pez x no se come
al pez y entonces existe un pez z tal que z es un tiburón o bien
z protege al pez y.
* No hay ningún pez que se coma a todos los demás.
* Ningún pez protege a ningún otro.
Por tanto, existe algún tiburón en la pecera.
Usar C(x,y) para x se come a y
P(x,y) para x protege a y
T(x) para x es un tiburón
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 27. Formalizar, y decidir la corrección, del siguiente
argumento
Supongamos conocidos los siguientes hechos acerca del número de
aprobados de dos asignaturas A y B:
* Si todos los alumnos aprueban la asignatura A, entonces todos
aprueban la asignatura B.
* Si algún delegado de la clase aprueba A y B, entonces todos los
alumnos aprueban A.
* Si nadie aprueba B, entonces ningún delegado aprueba A.
* Si Manuel no aprueba B, entonces nadie aprueba B.
Por tanto, si Manuel es un delegado y aprueba la asignatura A,
entonces todos los alumnos aprueban las asignaturas A y B.
Usar A(x,y) para x aprueba la asignatura y
D(x) para x es delegado
m para Manuel
a para la asignatura A
b para la asignatura B
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 28. Formalizar, y decidir la corrección, del siguiente
argumento
En cierto país oriental se ha celebrado la fase final del
campeonato mundial de fútbol. Cierto diario deportivo ha publicado
las siguientes estadísticas de tan magno acontecimiento:
* A todos los porteros que no vistieron camiseta negra les marcó un
gol algún delantero europeo.
* Algún portero jugó con botas blancas y sólo le marcaron goles
jugadores con botas blancas.
* Ningún portero se marcó un gol a sí mismo.
* Ningún jugador con botas blancas vistió camiseta negra.
Por tanto, algún delantero europeo jugó con botas blancas.
Usar P(x) para x es portero
D(x) para x es delantero europeo
N(x) para x viste camiseta negra
B(x) para x juega con botas blancas
M(x,y) para x marcó un gol a y
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 29. Formalizar, y decidir la corrección, del siguiente
argumento
Las relaciones de parentesco verifican la siguientes propiedades
generales:
* Si x es hermano de y, entonces y es hermano de x.
* Todo el mundo es hijo de alguien.
* Nadie es hijo del hermano de su padre.
* Cualquier padre de una persona es también padre de todos los
hermanos de esa persona.
* Nadie es hijo ni hermano de sí mismo.
Tenemos los siguientes miembros de la familia Peláez: Don Antonio,
Don Luis, Antoñito y Manolito y sabemos que Don Antonio y Don Luis
son hermanos, Antoñito y Manolito son hermanos, y Antoñito es hijo
de Don Antonio. Por tanto, Don Luis no es el padre de Manolito.
Usar A para Don Antonio
He(x,y) para x es hermano de y
Hi(x,y) para x es hijo de y
L para Don Luis
a para Antoñito
m para Manolito
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 30. [Problema del apisonador de Schubert (en inglés,
"Schubert’s steamroller")] Formalizar, y decidir la corrección, del
siguiente argumento
Si uno de los miembros del club afeita a algún otro (incluido a
sí mismo), entonces todos los miembros del club lo han afeitado
a él (aunque no necesariamente al mismo tiempo). Guido, Lorenzo,
Petruccio y Cesare pertenecen al club de barberos. Guido ha
afeitado a Cesare. Por tanto, Petruccio ha afeitado a Lorenzo.
Usar g para Guido
l para Lorenzo
p para Petruccio
c para Cesare
B(x) para x es un miembro del club de barberos
A(x,y) para x ha afeitado a y
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 31. Formalizar, y decidir la corrección, del siguiente
argumento
Carlos afeita a todos los habitantes de Las Chinas que no se
afeitan a sí mismo y sólo a ellos. Carlos es un habitante de las
Chinas. Por consiguiente, Carlos no afeita a nadie.
Usar A(x,y) para x afeita a y
C(x) para x es un habitante de Las Chinas
c para Carlos
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 32. Formalizar, y decidir la corrección, del siguiente
argumento
Quien desprecia a todos los fanáticos desprecia también a todos los
políticos. Alguien no desprecia a un determinado político. Por
consiguiente, hay un fanático al que no todo el mundo desprecia.
Usar D(x,y) para x desprecia a y
F(x) para x es fanático
P(x) para x es político
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 33. Formalizar, y decidir la corrección, del siguiente
argumento
El hombre puro ama todo lo que es puro. Por tanto, el hombre puro
se ama a sí mismo.
Usar A(x,y) para x ama a y
H(x) para x es un hombre
P(x) para x es puro
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 35. Formalizar, y decidir la corrección, del siguiente
argumento
1. Los lobos, zorros, pájaros, orugas y caracoles son animales y
existen algunos ejemplares de estos animales.
2. También hay algunas semillas y las semillas son plantas.
3. A todo animal le gusta o bien comer todo tipo de plantas o bien
le gusta comerse a todos los animales más pequeños que él mismo
que gustan de comer algunas plantas.
4. Las orugas y los caracoles son mucho más pequeños que los
pájaros, que son mucho más pequeños que los zorros que a su vez
son mucho más pequeños que los lobos.
5. A los lobos no les gusta comer ni zorros ni semillas, mientras
que a los pájaros les gusta comer orugas pero no caracoles.
6. Las orugas y los caracoles gustan de comer algunas plantas.
7. Luego, existe un animal al que le gusta comerse un animal al que
le gusta comer semillas.
Usar A(x) para x es un animal
Ca(x) para x es un caracol
Co(x,y) para x le gusta comerse a y
L(x) para x es un lobo
M(x,y) para x es más pequeño que y
Or(x) para x es una oruga
Pa(x) para x es un pájaro
Pl(x) para x es una planta
S(x) para x es una semilla
Z(x) para x es un zorro
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 36. Formalizar, y decidir la corrección, del siguiente
argumento
Rosa ama a Curro. Paco no simpatiza con Ana. Quien no simpatiza con
Ana ama a Rosa. Si una persona ama a otra, la segunda ama a la
primera. Hay como máximo una persona que ama a Rosa. Por tanto,
Paco es Curro.
Usar A(x,y) para x ama a y
S(x,y) para x simpatiza con y
a para Ana
c para Curro
p para Paco
r para Rosa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 37. Formalizar, y decidir la corrección, del siguiente
argumento
Sólo hay un sofista que enseña gratuitamente, y éste es
Sócrates. Sócrates argumenta mejor que ningún otro sofista. Platón
argumenta mejor que algún sofista que enseña gratuitamente. Si una
persona argumenta mejor que otra segunda, entonces la segunda no
argumenta mejor que la primera. Por consiguiente, Platón no es un
sofista.
Usar G(x) para x enseña gratuitamente
M(x,y) para x argumenta mejor que y
S(x) para x es un sofista
p para Platón
s para Sócrates
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 38. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los filósofos se han preguntado qué es la filosofía. Los que
se preguntan qué es la filosofía se vuelven locos. Nietzsche es
filósofo. El maestro de Nietzsche no acabó loco. Por tanto,
Nietzsche y su maestro son diferentes personas.
Usar F(x) para x es filósofo
L(x) para x se vuelve loco
P(x) para x se ha preguntado qué es la filosofía.
m para el maestro de Nietzsche
n para Nietzsche
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 39. Formalizar, y decidir la corrección, del siguiente
argumento
Los padres son mayores que los hijos. Juan es el padre de Luis. Por
tanto, Juan es mayor que Luis.
Usar M(x,y) para x es mayor que y
p(x) para el padre de x
j para Juan
l para Luis
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 41. Formalizar, y decidir la corrección, del siguiente
argumento
Luis y Jaime tienen el mismo padre. La madre de Rosa es
Eva. Eva ama a Carlos. Carlos es el padre de Jaime. Por tanto,
la madre de Rosa ama al padre de Luis.
Usar A(x,y) para x ama a y
m(x) para la madre de x
p(x) para el padre de x
c para Carlos
e para Eva
j para Jaime
l para Luis
r para Rosa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 42. Formalizar, y decidir la corrección, del siguiente
argumento
Si dos personas son hermanos, entonces tienen la misma madre y el
mismo padre. Juan es hermano de Luis. Por tanto, la madre del padre
de Juan es la madre del padre de Luis.
Usar H(x,y) para x es hermano de y
m(x) para la madre de x
p(x) para el padre de x
j para Juan
l para Luis
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 43. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los miembros del claustro son asturianos. El secretario forma
parte del claustro. El señor Martínez es el secretario. Por tanto,
el señor Martínez es asturiano.
Usar C(x) para x es miembro del claustro
A(x) para x es asturiano
s para el secretario
m para el señor Martínez
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 44. Formalizar, y decidir la corrección, del siguiente
argumento
Eduardo pudo haber visto al asesino. Antonio fue el primer testigo
de la defensa. O Eduardo estaba en clase o Antonio dio falso
testimonio. Nadie en clase pudo haber visto al asesino. Luego, el
primer testigo de la defensa dio falso testimonio.
Usar C(x) para x estaba en clase
F(x) para x dio falso testimonio
V(x) para x pudo haber visto al asesino
a para Antonio
e para Eduardo
p para el primer testigo de la defensa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 45. Formalizar, y decidir la corrección, del siguiente
argumento
La luna hoy es redonda. La luna de hace dos semanas tenía forma de
cuarto creciente. Luna no hay más que una, es decir, siempre es la
misma. Luego existe algo que es a la vez redondo y con forma de
cuarto creciente.
Usar L(x) para la luna del momento x
R(x) para x es redonda
C(x) para x tiene forma de cuarto creciente
h para hoy
d para hace dos semanas
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 46. Formalizar, y decidir la corrección, del siguiente
argumento
Juana sólo tiene un marido. Juana está casada con Tomás. Tomás es
delgado y Guillermo no. Luego, Juana no está casada con Guillermo.
Usar D(x) para x es delgado
C(x,y) para x está casada con y
g para Guillermo
j para Juana
t para Tomás
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 47. Formalizar, y decidir la corrección, del siguiente
argumento
Sultán no es Chitón. Sultán no obtendrá un plátano a menos que
pueda resolver cualquier problema. Si el chimpancé Chitón trabaja
más que Sultán resolverá problemas que Sultán no puede resolver.
Todos los chimpancés distintos de Sultán trabajan más que Sultán.
Por consiguiente, Sultán no obtendrá un plátano.
Usar Pl(x) para x obtiene el plátano
Pr(x) para x es un problema
R(x,y) para x resuelve y
T(x,y) para x trabaja más que y
c para Chitón
s para Sultán
------------------------------------------------------------------ *}

end
</source>

R10

2014-12-18T10:13:16Z

Jalonso:

R10

2014-12-18T10:12:53Z

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

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

theory R10_Formalizacion_y_argmentacion
imports Main
begin

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

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

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 1. Formalizar, y demostrar la corrección, del siguiente
argumento
Si no está el mañana ni el ayer escrito, entonces no está el mañana
escrito.
Usar M: El mañana está escrito.
A: El ayer está escrito.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 2. Formalizar, y demostrar la corrección, del siguiente
argumento
Siempre que un número x es divisible por 10, acaba en 0. El número
x no acaba en 0. Por lo tanto, x no es divisible por 10.
Usar D para "el número es divisible por 10" y
C para "el número acaba en cero".
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 3. Formalizar, y demostrar la corrección, del siguiente
argumento
Si no hay control de nacimientos, entonces la población crece
ilimitadamente; pero si la población crece ilimitadamente,
aumentará el índice de pobreza. Por consiguiente, si no hay control
de nacimientos, aumentará el índice de pobreza.
Usar N: Hay control de nacimientos.
P: La población crece ilimitadamente,
I: Aumentará el índice de pobreza.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 4. Formalizar, y demostrar la corrección, del siguiente
argumento
Si te llamé por teléfono, entonces recibiste mi llamada y no es
cierto que no te avisé del peligro que corrías. Por consiguiente,
como te llamé, es cierto que te avisé del peligro que corrías.
Usar T: Te llamé por teléfono.
R: Recibiste mi llamada.
P: Te avisé del peligro que corrías.
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 6. Formalizar, y demostrar la corrección, del siguiente
argumento
Cuando tanto la temperatura como la presión atmosférica permanecen
contantes, no llueve. La temperatura permanece constante. Por lo
tanto, en caso de que llueva, la presión atmosférica no permanece
constante.
Usar T para "La temperatura permanece constante",
P para "La presión atmosférica permanece constante" y
L para "Llueve".
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 7. Formalizar, y demostrar la corrección, del siguiente
argumento
Si el general era leal, hubiera obedecido las órdenes, y si era
inteligente las hubiera comprendido. O el general desobedeció las
órdenes o no las comprendió. Luego, el general era desleal o no era
inteligente.
Usar L: El general es leal.
Ob: El general obedece las órdenes.
I: El general es inteligente.
C: El general comprende las órdenes.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 8. Formalizar, y demostrar la corrección, del siguiente
argumento
Me matan si no trabajo y si trabajo me matan. Me matan siempre me
matan.
Usar M: Me matan.
T: Trabajo.
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 10. Formalizar, y demostrar la corrección, del siguiente
argumento
Si trabajo gano dinero, pero si no trabajo gozo de la vida. Sin
embargo, si trabajo no gozo de la vida, mientras que si no trabajo
no gano dinero. Por lo tanto, gozo de la vida si y sólo si no gano
dinero.
Usar p: Trabajo
q: Gano dinero.
r: Gozo de la vida.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 11. Formalizar, y demostrar la corrección, del siguiente
argumento
Si Dios fuera capaz de evitar el mal y quisiera hacerlo, lo
haría. Si Dios fuera incapaz de evitar el mal, no sería
omnipotente; si no quisiera evitar el mal sería malévolo. Dios no
evita el mal. Si Dios existe, es omnipotente y no es
malévolo. Luego, Dios no existe.
Usar C: Dios es capaz de evitar el mal.
Q: Dios quiere evitar el mal.
Om: Dios es omnipotente.
M: Dios es malévolo.
P: Dios evita el mal.
E: Dios existe.
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 12. Formalizar, y decidir la corrección, del siguiente
argumento
Sócrates es un hombre.
Los hombres son mortales.
Luego, Sócrates es mortal.
Usar s para Sócrates
H(x) para x es un hombre
M(x) para x es mortal
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 14. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los participantes son vencedores. Hay como máximo un
vencedor. Hay como máximo un participante. Por lo tanto, hay
exactamente un participante.
Usar P(x) para x es un participante
V(x) para x es un vencedor
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 15. Formalizar, y decidir la corrección, del siguiente
argumento
Todo aquel que entre en el país y no sea un VIP será cacheado por
un aduanero. Hay un contrabandista que entra en el país y que solo
podrá ser cacheado por contrabandistas. Ningún contrabandista es un
VIP. Por tanto, algún aduanero es contrabandista.
Usar A(x) para x es aduanero
Ca(x,y) para x cachea a y
Co(x) para x es contrabandista
E(x) para x entra en el pais
V(x) para x es un VIP
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 16. Formalizar, y decidir la corrección, del siguiente
argumento
Juan teme a María. Pedro es temido por Juan. Luego, alguien teme a
María y a Pedro.
Usar j para Juan
m para María
p para Pedro
T(x,y) para x teme a y
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 18. Formalizar, y decidir la corrección, del siguiente
argumento
La existencia de algún canal de TV pública, supone un acicate para
cualquier canal de TV privada; el que un canal de TV tenga un
acicate, supone una gran satisfacción para cualquiera de sus
directivos; en Madrid hay varios canales públicos de TV; TV5 es un
canal de TV privada; por tanto, todos los directivos de TV5 están
satisfechos.
Usar Pu(x) para x es un canal de TV pública
Pr(x) para x es un canal de TV privada
A(x) para x posee un acicate
D(x,y) para x es un directivo del canal y
S(x) para x está satisfecho
t para TV5
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 19. Formalizar, y decidir la corrección, del siguiente
argumento
Quien intente entrar en un país y no tenga pasaporte, encontrará
algún aduanero que le impida el paso. A algunas personas
motorizadas que intentan entrar en un país le impiden el paso
únicamente personas motorizadas. Ninguna persona motorizada tiene
pasaporte. Por tanto, ciertos aduaneros están motorizados.
Usar E(x) para x entra en un país
P(x) para x tiene pasaporte
A(x) para x es aduanero
I(x,y) para x impide el paso a y
M(x) para x está motorizada
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 21. Formalizar, y decidir la corrección, del siguiente
argumento
Ningún aristócrata debe ser condenado a galeras a menos que sus
crímenes sean vergonzosos y lleve una vida licenciosa. En la ciudad
hay aristócratas que han cometido crímenes vergonzosos aunque su
forma de vida no sea licenciosa. Por tanto, hay algún aristócrata
que no está condenado a galeras.
Usar A(x) para x es aristócrata
G(x) para x está condenado a galeras
L(x) para x lleva una vida licenciosa
V(x) para x ha cometido crímenes vergonzoso
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 22. Formalizar, y decidir la corrección, del siguiente
argumento
Todo individuo que esté conforme con el contenido de cualquier
acuerdo internacional lo apoya o se inhibe en absoluto de asuntos
políticos. Cualquiera que se inhiba de los asuntos políticos, no
participará en el próximo referéndum. Todo español, está conforme
con el acuerdo internacional de Maastricht, al que sin embargo no
apoya. Por tanto, cualquier individuo o no es español, o en otro
caso, está conforme con el contenido del acuerdo internacional de
Maastricht y no participará en el próximo referéndum.
Usar C(x,y) para la persona x conforme con el contenido del acuerdo y
A(x,y) para la persona x apoya el acuerdo y
I(x) para la persona x se inibe de asuntos políticos
R(x) para la persona x participará en el próximo referéndum
E(x) para la persona x es española
m para el acuerdo de Maastricht
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 24. Formalizar, y decidir la corrección, del siguiente
argumento
Todo deprimido que estima a un submarinista es listo. Cualquiera
que se estime a sí mismo es listo. Ningún deprimido se estima a sí
mismo. Por tanto, ningún deprimido estima a un submarinista.
Usar D(x) para x está deprimido
E(x,y) para x estima a y
L(x) para x es listo
S(x) para x es submarinista
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 25. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los robots obedecen a los amigos del programador jefe.
Alvaro es amigo del programador jefe, pero Benito no le
obedece. Por tanto, Benito no es un robot.
Usar R(x) para x es un robot
Ob(x,y) para x obedece a y
A(x) para x es amigo del programador jefe
b para Benito
a para Alvaro
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 26. Formalizar, y decidir la corrección, del siguiente
argumento
En una pecera nadan una serie de peces. Se observa que:
* Hay algún pez x que para cualquier pez y, si el pez x no se come
al pez y entonces existe un pez z tal que z es un tiburón o bien
z protege al pez y.
* No hay ningún pez que se coma a todos los demás.
* Ningún pez protege a ningún otro.
Por tanto, existe algún tiburón en la pecera.
Usar C(x,y) para x se come a y
P(x,y) para x protege a y
T(x) para x es un tiburón
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 27. Formalizar, y decidir la corrección, del siguiente
argumento
Supongamos conocidos los siguientes hechos acerca del número de
aprobados de dos asignaturas A y B:
* Si todos los alumnos aprueban la asignatura A, entonces todos
aprueban la asignatura B.
* Si algún delegado de la clase aprueba A y B, entonces todos los
alumnos aprueban A.
* Si nadie aprueba B, entonces ningún delegado aprueba A.
* Si Manuel no aprueba B, entonces nadie aprueba B.
Por tanto, si Manuel es un delegado y aprueba la asignatura A,
entonces todos los alumnos aprueban las asignaturas A y B.
Usar A(x,y) para x aprueba la asignatura y
D(x) para x es delegado
m para Manuel
a para la asignatura A
b para la asignatura B
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 28. Formalizar, y decidir la corrección, del siguiente
argumento
En cierto país oriental se ha celebrado la fase final del
campeonato mundial de fútbol. Cierto diario deportivo ha publicado
las siguientes estadísticas de tan magno acontecimiento:
* A todos los porteros que no vistieron camiseta negra les marcó un
gol algún delantero europeo.
* Algún portero jugó con botas blancas y sólo le marcaron goles
jugadores con botas blancas.
* Ningún portero se marcó un gol a sí mismo.
* Ningún jugador con botas blancas vistió camiseta negra.
Por tanto, algún delantero europeo jugó con botas blancas.
Usar P(x) para x es portero
D(x) para x es delantero europeo
N(x) para x viste camiseta negra
B(x) para x juega con botas blancas
M(x,y) para x marcó un gol a y
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 29. Formalizar, y decidir la corrección, del siguiente
argumento
Las relaciones de parentesco verifican la siguientes propiedades
generales:
* Si x es hermano de y, entonces y es hermano de x.
* Todo el mundo es hijo de alguien.
* Nadie es hijo del hermano de su padre.
* Cualquier padre de una persona es también padre de todos los
hermanos de esa persona.
* Nadie es hijo ni hermano de sí mismo.
Tenemos los siguientes miembros de la familia Peláez: Don Antonio,
Don Luis, Antoñito y Manolito y sabemos que Don Antonio y Don Luis
son hermanos, Antoñito y Manolito son hermanos, y Antoñito es hijo
de Don Antonio. Por tanto, Don Luis no es el padre de Manolito.
Usar A para Don Antonio
He(x,y) para x es hermano de y
Hi(x,y) para x es hijo de y
L para Don Luis
a para Antoñito
m para Manolito
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 30. [Problema del apisonador de Schubert (en inglés,
"Schubert’s steamroller")] Formalizar, y decidir la corrección, del
siguiente argumento
Si uno de los miembros del club afeita a algún otro (incluido a
sí mismo), entonces todos los miembros del club lo han afeitado
a él (aunque no necesariamente al mismo tiempo). Guido, Lorenzo,
Petruccio y Cesare pertenecen al club de barberos. Guido ha
afeitado a Cesare. Por tanto, Petruccio ha afeitado a Lorenzo.
Usar g para Guido
l para Lorenzo
p para Petruccio
c para Cesare
B(x) para x es un miembro del club de barberos
A(x,y) para x ha afeitado a y
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 31. Formalizar, y decidir la corrección, del siguiente
argumento
Carlos afeita a todos los habitantes de Las Chinas que no se
afeitan a sí mismo y sólo a ellos. Carlos es un habitante de las
Chinas. Por consiguiente, Carlos no afeita a nadie.
Usar A(x,y) para x afeita a y
C(x) para x es un habitante de Las Chinas
c para Carlos
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 32. Formalizar, y decidir la corrección, del siguiente
argumento
Quien desprecia a todos los fanáticos desprecia también a todos los
políticos. Alguien no desprecia a un determinado político. Por
consiguiente, hay un fanático al que no todo el mundo desprecia.
Usar D(x,y) para x desprecia a y
F(x) para x es fanático
P(x) para x es político
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 33. Formalizar, y decidir la corrección, del siguiente
argumento
El hombre puro ama todo lo que es puro. Por tanto, el hombre puro
se ama a sí mismo.
Usar A(x,y) para x ama a y
H(x) para x es un hombre
P(x) para x es puro
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 35. Formalizar, y decidir la corrección, del siguiente
argumento
1. Los lobos, zorros, pájaros, orugas y caracoles son animales y
existen algunos ejemplares de estos animales.
2. También hay algunas semillas y las semillas son plantas.
3. A todo animal le gusta o bien comer todo tipo de plantas o bien
le gusta comerse a todos los animales más pequeños que él mismo
que gustan de comer algunas plantas.
4. Las orugas y los caracoles son mucho más pequeños que los
pájaros, que son mucho más pequeños que los zorros que a su vez
son mucho más pequeños que los lobos.
5. A los lobos no les gusta comer ni zorros ni semillas, mientras
que a los pájaros les gusta comer orugas pero no caracoles.
6. Las orugas y los caracoles gustan de comer algunas plantas.
7. Luego, existe un animal al que le gusta comerse un animal al que
le gusta comer semillas.
Usar A(x) para x es un animal
Ca(x) para x es un caracol
Co(x,y) para x le gusta comerse a y
L(x) para x es un lobo
M(x,y) para x es más pequeño que y
Or(x) para x es una oruga
Pa(x) para x es un pájaro
Pl(x) para x es una planta
S(x) para x es una semilla
Z(x) para x es un zorro
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 36. Formalizar, y decidir la corrección, del siguiente
argumento
Rosa ama a Curro. Paco no simpatiza con Ana. Quien no simpatiza con
Ana ama a Rosa. Si una persona ama a otra, la segunda ama a la
primera. Hay como máximo una persona que ama a Rosa. Por tanto,
Paco es Curro.
Usar A(x,y) para x ama a y
S(x,y) para x simpatiza con y
a para Ana
c para Curro
p para Paco
r para Rosa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 37. Formalizar, y decidir la corrección, del siguiente
argumento
Sólo hay un sofista que enseña gratuitamente, y éste es
Sócrates. Sócrates argumenta mejor que ningún otro sofista. Platón
argumenta mejor que algún sofista que enseña gratuitamente. Si una
persona argumenta mejor que otra segunda, entonces la segunda no
argumenta mejor que la primera. Por consiguiente, Platón no es un
sofista.
Usar G(x) para x enseña gratuitamente
M(x,y) para x argumenta mejor que y
S(x) para x es un sofista
p para Platón
s para Sócrates
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 38. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los filósofos se han preguntado qué es la filosofía. Los que
se preguntan qué es la filosofía se vuelven locos. Nietzsche es
filósofo. El maestro de Nietzsche no acabó loco. Por tanto,
Nietzsche y su maestro son diferentes personas.
Usar F(x) para x es filósofo
L(x) para x se vuelve loco
P(x) para x se ha preguntado qué es la filosofía.
m para el maestro de Nietzsche
n para Nietzsche
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 39. Formalizar, y decidir la corrección, del siguiente
argumento
Los padres son mayores que los hijos. Juan es el padre de Luis. Por
tanto, Juan es mayor que Luis.
Usar M(x,y) para x es mayor que y
p(x) para el padre de x
j para Juan
l para Luis
------------------------------------------------------------------ *}

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

text {* ---------------------------------------------------------------
Ejercicio 41. Formalizar, y decidir la corrección, del siguiente
argumento
Luis y Jaime tienen el mismo padre. La madre de Rosa es
Eva. Eva ama a Carlos. Carlos es el padre de Jaime. Por tanto,
la madre de Rosa ama al padre de Luis.
Usar A(x,y) para x ama a y
m(x) para la madre de x
p(x) para el padre de x
c para Carlos
e para Eva
j para Jaime
l para Luis
r para Rosa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 42. Formalizar, y decidir la corrección, del siguiente
argumento
Si dos personas son hermanos, entonces tienen la misma madre y el
mismo padre. Juan es hermano de Luis. Por tanto, la madre del padre
de Juan es la madre del padre de Luis.
Usar H(x,y) para x es hermano de y
m(x) para la madre de x
p(x) para el padre de x
j para Juan
l para Luis
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 43. Formalizar, y decidir la corrección, del siguiente
argumento
Todos los miembros del claustro son asturianos. El secretario forma
parte del claustro. El señor Martínez es el secretario. Por tanto,
el señor Martínez es asturiano.
Usar C(x) para x es miembro del claustro
A(x) para x es asturiano
s para el secretario
m para el señor Martínez
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 44. Formalizar, y decidir la corrección, del siguiente
argumento
Eduardo pudo haber visto al asesino. Antonio fue el primer testigo
de la defensa. O Eduardo estaba en clase o Antonio dio falso
testimonio. Nadie en clase pudo haber visto al asesino. Luego, el
primer testigo de la defensa dio falso testimonio.
Usar C(x) para x estaba en clase
F(x) para x dio falso testimonio
V(x) para x pudo haber visto al asesino
a para Antonio
e para Eduardo
p para el primer testigo de la defensa
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 45. Formalizar, y decidir la corrección, del siguiente
argumento
La luna hoy es redonda. La luna de hace dos semanas tenía forma de
cuarto creciente. Luna no hay más que una, es decir, siempre es la
misma. Luego existe algo que es a la vez redondo y con forma de
cuarto creciente.
Usar L(x) para la luna del momento x
R(x) para x es redonda
C(x) para x tiene forma de cuarto creciente
h para hoy
d para hace dos semanas
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 46. Formalizar, y decidir la corrección, del siguiente
argumento
Juana sólo tiene un marido. Juana está casada con Tomás. Tomás es
delgado y Guillermo no. Luego, Juana no está casada con Guillermo.
Usar D(x) para x es delgado
C(x,y) para x está casada con y
g para Guillermo
j para Juana
t para Tomás
------------------------------------------------------------------ *}

text {* ---------------------------------------------------------------
Ejercicio 47. Formalizar, y decidir la corrección, del siguiente
argumento
Sultán no es Chitón. Sultán no obtendrá un plátano a menos que
pueda resolver cualquier problema. Si el chimpancé Chitón trabaja
más que Sultán resolverá problemas que Sultán no puede resolver.
Todos los chimpancés distintos de Sultán trabajan más que Sultán.
Por consiguiente, Sultán no obtendrá un plátano.
Usar Pl(x) para x obtiene el plátano
Pr(x) para x es un problema
R(x,y) para x resuelve y
T(x,y) para x trabaja más que y
c para Chitón
s para Sultán
------------------------------------------------------------------ *}

end
</source>

R10

2014-12-18T10:12:38Z

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

Relación 9

2014-12-18T10:11:24Z

Jalonso: Página creada con '<source lang="isar"> header {* R9: Deducción natural en Isabelle/HOL *} theory R9 imports Main begin text {* Demostrar o refutar los siguientes lemas usando sólo las regl...'

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

theory R9
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 ∨ q, ¬q ⊢ p
------------------------------------------------------------------ *}

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

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

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

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

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

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

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

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

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 13. 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)
------------------------------------------------------------------ *}

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

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

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

text {* ---------------------------------------------------------------
Ejercicio 17. 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))
------------------------------------------------------------------ *}

end
</source>

R9

2014-12-18T10:10:45Z

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

R9

2014-12-18T10:10:28Z

Ejercicios

2014-12-18T10:07:14Z

Jalonso: /* Relaciones de ejercicios propuestos */

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

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

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

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

2014-12-18T09:26:01Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 8: Deducción natural en lógica de primer orden *} theory T8b imports Main begin text {* El objetivo de este tema es presentar la deduc...'

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

theory T8b
imports Main
begin

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

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

section {* Reglas del cuantificador universal *}

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

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

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

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

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

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

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

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

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

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

section {* Reglas del cuantificador existencial *}

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

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

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

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

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

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

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

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

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

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

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

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

section {* Demostración de equivalencias *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

section {* Reglas de la igualdad *}

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

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

2014-12-18T09:24:56Z

Jalonso: Página creada con '<source lang="isar"> header {* Tema 7b: Deducción natural proposicional con Isabelle/HOL *} theory T7b imports Main begin text {* En este tema se presentan los ejemplos de...'

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

theory T7b
imports Main
begin

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

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

subsection {* Reglas de la conjunción *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

subsection {* Regla derivada del modus tollens *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

subsection {* Reglas de la disyunción *}

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

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

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

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

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

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

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

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

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

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

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

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

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

subsection {* Regla de copia *}

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

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

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

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

subsection {* Reglas de la negación *}

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

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

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

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

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

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

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

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

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

subsection {* Reglas del bicondicional *}

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

text {*
Ejemplo 17 (p. 17) Demostrar
*}

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

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

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

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

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

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

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

subsection {* Reglas derivadas *}

subsubsection {* Regla del modus tollens *}

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

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

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

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

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

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

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

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

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

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

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

subsubsection {* Ley del tercio excluso *}

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

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

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

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

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

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

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

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

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

subsection {* Demostraciones por contradicción *}

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

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

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

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

end
</source>

Temas

2014-12-18T09:23:59Z

Jalonso: /* Temas de Razonamiento automático (2014-15) */

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

Relación 8

2014-12-04T12:56:00Z

Jalonso: Página creada con '<source lang="isar"> header {* R8: Árboles binarios completos *} theory R8_Arboles_binarios_completos imports Main begin text {* ---------------------------------------...'

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

theory R8_Arboles_binarios_completos
imports Main
begin

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

datatype arbol = H | N arbol arbol

value "N (N H H) (N H H)"

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

fun hojas :: "arbol => nat" where
"hojas t = undefined"

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

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

fun profundidad :: "arbol => nat" where
"profundidad t = undefined"

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

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

fun abc :: "nat ⇒ arbol" where
"abc 0 = undefined"

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

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

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

fun es_abc :: "(arbol => 'a) => arbol => bool" where
"es_abc f t = undefined"

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

value "size (N (N H H) (N H H))"
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"

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

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

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

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

text {*
---------------------------------------------------------------------
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 11. Demostrar que si a es un árbolo binario completo
respecto de la profundidad, entonces a es (abc (profundidad a)).
---------------------------------------------------------------------
*}

text {*
---------------------------------------------------------------------
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de
(es_abc size).
---------------------------------------------------------------------
*}

end
</source>

R8

2014-12-04T12:55:45Z

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

R8

2014-12-04T12:55:16Z

Ejercicios

2014-12-04T12:54:31Z

Jalonso:

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

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

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

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

2014-12-04T10:52:05Z

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

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

theory T6
imports Main
begin

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

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

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

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

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

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

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

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

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

section {* La máquina de pila *}

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

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

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

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

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

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

section {* El compilador *}

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

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

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

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

section {* Corrección del compilador *}

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

Temas

2014-12-04T10:51:43Z

Jalonso:

== Temas de ''Razonamiento automático (2014-15)'' ==
* [[Tema 1: Programación funcional en Isabelle]].
* [http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-8t.pdf Tema 2a: Razonamiento sobre programas Haskell]
* [[Tema 2b: Razonamiento automático sobre programas en Isabelle/HOL]].
* [[Tema 3: Razonamiento estructurado sobre programas en Isabelle/HOL]].
* [[Tema 4: Razonamiento por casos y por inducción]].
* [[Tema 5a: Verificación de la ordenación por inserción]].
* [[Tema 5b: Verificación de la ordenación por mezcla]].
* [[Tema 6: Caso de estudio: Compilación de expresiones]].

Relación 7

2014-11-28T13:04:52Z

Jalonso: Página creada con '<source lang="isar"> header {* R7: Recorridos de árboles *} theory R7 imports Main begin text {* --------------------------------------------------------------------- ...'

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

theory R7
imports Main
begin

text {*
---------------------------------------------------------------------
Ejercicio 1. Definir el tipo de datos arbol para representar los
árboles binarios que tiene información en los nodos y en las hojas.
Por ejemplo, el árbol
e
/ \
/ \
c g
/ \ / \
a d f h
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".
---------------------------------------------------------------------
*}

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

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

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

fun preOrden :: "'a arbol ⇒ 'a list" where
"preOrden t = undefined"

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

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

fun postOrden :: "'a arbol ⇒ 'a list" where
"postOrden t = undefined"

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

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

fun inOrden :: "'a arbol ⇒ 'a list" where
"inOrden t = undefined"

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

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

fun espejo :: "'a arbol ⇒ 'a arbol" where
"espejo t = undefined"

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

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

lemma "preOrden (espejo a) = rev (postOrden a)"
oops

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

lemma "postOrden (espejo a) = rev (preOrden a)"
oops

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

theorem "inOrden (espejo a) = rev (inOrden a)"
oops

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

fun raiz :: "'a arbol ⇒ 'a" where
"raiz t = undefined"

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

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

fun extremo_izquierda :: "'a arbol ⇒ 'a" where
"extremo_izquierda t = undefined"

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

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

fun extremo_derecha :: "'a arbol ⇒ 'a" where
"extremo_derecha t = undefined"

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

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

theorem "last (inOrden a) = extremo_derecha a"
oops

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

theorem "hd (inOrden a) = extremo_izquierda a"
oops

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

theorem "hd (preOrden a) = last (postOrden a)"
oops

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

theorem "hd (preOrden a) = raiz a"
oops

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

theorem "hd (inOrden a) = raiz a"
oops

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

theorem "last (postOrden a) = raiz a"
oops

end
</source>

R7

2014-11-28T13:04:35Z

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

R7

2014-11-28T13:04:24Z

Ejercicios

2014-11-28T13:03:53Z

Jalonso: /* Relaciones de ejercicios propuestos */

== Relaciones de ejercicios ==

=== Relaciones de ejercicios propuestos ===

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

* '''Relación 1''': Programación funcional en Isabelle/HOL. ([[R1 |Enunciado]] y [[Relación 1 | Solución colaborativa]]).
* '''Relación 2''': Razonamiento automático sobre programas en Isabelle/HOL. ([[R2 |Enunciado]] y [[Relación 2 | Solución colaborativa]]).
* '''Relación 3''': Razonamiento estructurado sobre programas en Isabelle/HOL. ([[R3 |Enunciado]] y [[Relación 3 | Solución colaborativa]]).
* '''Relación 4''': Cons inverso. ([[R4 |Enunciado]] y [[Relación 4 | Solución colaborativa]]).
* '''Relación 5''': Cuantificadores sobre listas. ([[R5 |Enunciado]] y [[Relación 5 | Solución colaborativa]]).
* '''Relación 6''': Sustitución, inversión y eliminación. ([[R6 |Enunciado]] y [[Relación 6 | Solución colaborativa]]).
* '''Relación 7''': Recorridos de árboles. ([[R7 |Enunciado]] y [[Relación 7 | Solución colaborativa]]).

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

2014-11-27T12:02:20Z

Jalonso: Página creada con '<source lang="isar"> header {* T5b: Verificación de la ordenación por mezcla *} theory T5b_Verificacion_de_la_ordenacion_por_mezcla_sol imports Main begin text {* En esta ...'

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

theory T5b_Verificacion_de_la_ordenacion_por_mezcla_sol
imports Main
begin

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

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

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

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

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

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

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

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

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

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

section {* Ordenación por mezcla *}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

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

2014-11-27T12:01:52Z

Jalonso: Página creada con '<source lang="isar"> header {* T5a: Verificación de la ordenación por inserción *} theory T5a_Verificacion_de_la_ordenacion_por_insercion imports Main begin text {* En es...'

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

theory T5a_Verificacion_de_la_ordenacion_por_insercion
imports Main
begin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

end
</source>

Temas

2014-11-27T12:01:26Z

Jalonso: /* Temas de Razonamiento automático (2014-15) */

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

Temas

2014-11-27T11:59:49Z

Jalonso: /* Temas de Razonamiento automático (2014-15) */

Relación 6

2014-11-22T06:25:02Z

Jalonso: Página creada con '<source lang="isar"> header {* R6: Sustitución, inversión y eliminación *} theory R6_Sustitucion_inversion_y_eliminacion imports Main begin text {* Nota: En esta relaci...'

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

theory R6_Sustitucion_inversion_y_eliminacion
imports Main
begin

text {*
Nota: En esta relación se pide hacer las demostraciones de forma
automática. *}

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

fun sust :: "'a ⇒ 'a ⇒ 'a list ⇒ 'a list" where
"sust x y zs = undefined"

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

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

lemma sust_append:
"sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"
oops

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

lemma rev_sust:
"rev(sust x y zs) = sust x y (rev zs)"
oops

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

lemma "sust x y (sust u v zs) = sust u v (sust x y zs)"
oops

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

lemma "sust y z (sust x y zs) = sust x z zs"
oops

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

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

fun borra :: "'a ⇒ 'a list ⇒ 'a list" where
"borra x ys = undefined"

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

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

fun borraTodas :: "'a ⇒ 'a list ⇒ 'a list" where
"borraTodas x ys = undefined"

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

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

lemma "borra x (borraTodas x xs) = borraTodas x xs"
oops

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

lemma "borraTodas x (borraTodas x xs) = borraTodas x xs"
oops

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

lemma borraTodas_borra:
"borraTodas x (borra x xs) = borraTodas x xs"
oops

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

lemma "borra x (borra y xs) = borra y (borra x xs)"
oops

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

lemma "borraTodas x (borra y xs) = borra y (borraTodas x xs)"
oops

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

lemma "borra y (sust x y xs) = borra x xs"
oops

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

lemma "borraTodas y (sust x y xs) = borraTodas x xs"
oops

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

lemma "sust x y (borraTodas x zs) = borraTodas x zs"
oops

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

lemma "sust x y (borraTodas z zs) = borraTodas z (sust x y zs)"
oops

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

lemma "rev (borra x xs) = borra x (rev xs)"
oops

text {*
---------------------------------------------------------------------
Ejercicio 18. Demostrar o refutar
borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)
---------------------------------------------------------------------
*}

lemma borraTodas_append:
"borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"
oops

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

lemma "rev (borraTodas x xs) = borraTodas x (rev xs)"
oops

end </source>

R6

2014-11-22T06:24:46Z

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

R6

2014-11-22T06:23:57Z

Jalonso: