{"id":22452403,"url":"https://github.com/jaalonso/explorando-con-lean","last_synced_at":"2025-03-27T12:41:16.798Z","repository":{"id":39363624,"uuid":"504088220","full_name":"jaalonso/Explorando-con-Lean","owner":"jaalonso","description":"Explorando formalizaciones con Lean","archived":false,"fork":false,"pushed_at":"2022-07-09T16:46:22.000Z","size":38,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-01T17:13:20.105Z","etag":null,"topics":["automated-reasoning","interactive-theorem-proving","lean","math","proof-assistant"],"latest_commit_sha":null,"homepage":"","language":"Lean","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"gpl-3.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jaalonso.png","metadata":{"files":{"readme":"README.org","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2022-06-16T09:13:11.000Z","updated_at":"2023-02-15T12:04:15.000Z","dependencies_parsed_at":"2022-07-11T21:52:09.628Z","dependency_job_id":null,"html_url":"https://github.com/jaalonso/Explorando-con-Lean","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jaalonso%2FExplorando-con-Lean","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jaalonso%2FExplorando-con-Lean/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jaalonso%2FExplorando-con-Lean/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jaalonso%2FExplorando-con-Lean/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jaalonso","download_url":"https://codeload.github.com/jaalonso/Explorando-con-Lean/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":245849669,"owners_count":20682628,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["automated-reasoning","interactive-theorem-proving","lean","math","proof-assistant"],"created_at":"2024-12-06T06:11:08.134Z","updated_at":"2025-03-27T12:41:16.692Z","avatar_url":"https://github.com/jaalonso.png","language":"Lean","funding_links":[],"categories":[],"sub_categories":[],"readme":"#+TITLE: Explorando formalizaciones con Lean\n#+OPTIONS: num:t\n \nEstas son las notas de la lectura del libro de [[https://loeh.app.uni-regensburg.de/index.html][Clara Löh]] titulado\n[[https://loeh.app.uni-regensburg.de/mapa/main.pdf][Exploring formalisation (A primer in human-readable mathematics in Lean\n3 with examples from simplicial topology)]] cuyo código se encuentra en\n[[https://gitlab.com/polywuisch/mapa_notes][GitLab]].\n\n* Contenido                                                             :TOC:\n- [[#introducción][Introducción]]\n- [[#el-asistente-de-pruebas-lean][El asistente de pruebas Lean]]\n  - [[#asistentes-de-pruebas][Asistentes de pruebas]]\n  - [[#fundamentos][Fundamentos]]\n  - [[#tipos][Tipos]]\n  - [[#demostraciones][Demostraciones]]\n- [[#ejemplos-básicos][Ejemplos básicos]]\n  - [[#aplicaciones-inyectivas-y-suprayectivas][Aplicaciones inyectivas y suprayectivas]]\n  - [[#inducción][Inducción]]\n  - [[#conmutadores][Conmutadores]]\n  - [[#el-cero-real][El cero real]]\n  - [[#ejercicios][Ejercicios]]\n- [[#opciones-de-diseño][Opciones de diseño]]\n  - [[#diseño-recursivo][Diseño recursivo]]\n  - [[#complejos-simpliciales][Complejos simpliciales]]\n  - [[#aplicaciones-simpliciales][Aplicaciones simpliciales]]\n  - [[#complejos-simpliciales-finitos][Complejos simpliciales finitos]]\n  - [[#generación-de-complejos-simpliciales][Generación de complejos simpliciales]]\n  - [[#combinación-de-complejos-simpliciales][Combinación de complejos simpliciales]]\n  - [[#la-característica-de-euler][La característica de Euler]]\n  - [[#hacia-una-biblioteca][Hacia una biblioteca]]\n  - [[#ejercicios-1][Ejercicios]]\n- [[#abstracción-y-prototipado][Abstracción y prototipado]]\n  - [[#formalización-directa-seminormas-functoriales][Formalización directa: Seminormas functoriales]]\n  - [[#formalización-indirecta-multiplicidad-susceptible][Formalización indirecta: Multiplicidad susceptible]]\n\n* Introducción\n\n+ La formalización de las matemáticas en un asistente de pruebas tiene\n  los siguientes beneficios:\n  + La implementación de las matemáticas requiere un conocimiento muy\n    profundo de del tema y de todos los casos extremos. Por lo tanto,\n    una formalización exitosa permite un mejor conocimiento de los\n    detalles.\n  + Una formalización en un asistente de pruebas puede conducir a un\n    código ejecutable y, por tanto ofrece la oportunidad de realizar\n    experimentos con ejemplos concretos.\n  + Los asistentes de pruebas fomentan la abstracción. A menudo es más\n    fácil formalizar conceptos de forma declarativa a través de\n    propiedades universales en lugar de construcciones concretas y\n    potencialmente engorrosas. Esto puede conducir a una una visión más\n    clara de las cuestiones e ideas fundamentales.\n  + Interactuar con un asistente de pruebas es divertido y adictivo.\n\n+ Si los estudiantes aprenden las técnicas básicas de demostración a\n  través de un asistente de pruebas, pueden obtener una\n  retroalimentación inmediata y pueden experimentar con pruebas y\n  ejemplos. Además, los estudiantes pueden ver en términos más prácticos\n  cómo las abstracciones simplifican la vida matemática.\n  \n* El asistente de pruebas Lean\n\n** Asistentes de pruebas\n\n+ Un asistente de pruebas es un lenguaje de programación junto con su\n  correspondiente intérprete/compilador que nos permite formalizar\n  objetos y hechos matemáticos (definiciones, teoremas, pruebas y\n  ejemplos).\n\n+ La principal tarea de un asistente de pruebas no es encontrar pruebas,\n  sino comprobar que las pruebas son correctas.\n\n+ Los asistentes de pruebas ayudan a detectar y evitar errores. Además,\n  indirectamente también conducen a una mejor comprensión general de las\n  conexiones matemáticas y, a largo plazo, conducirán a formas más\n  sistemáticas y estructuradas de generalizar los resultados a nuevos\n  contextos.\n\n+ Uno de los grandes retos es utilizar los asistentes de pruebas de tal\n  manera que la formalización no sólo sea fácil de comprobar por el\n  intérprete/compilador sino también comprensible para los lectores\n  humanos: La belleza de las matemáticas no reside en los complicados\n  detalles técnicos, sino en las ideas subyacentes.\n\n+ Hay muchos asistentes de pruebas; actualmente, los asistentes de\n  pruebas de propósito general más populares son Coq, Isabelle y Lean.\n\n** Fundamentos\n\n+ La formalización de las matemáticas consta de los siguientes componentes\n  - un universo de objetos,\n  - un lenguaje lógico,\n  - un concepto de prueba y\n  - un metalenguaje (en el que se formula todo esto).\n\n+ En las pruebas clásicas de papel y lápiz, solemos trabajar con la\n  teoría de conjuntos, con una lógica clásica y con un cálculo de\n  pruebas que nos permite descomponer, construir y recombinar enunciados\n  lógicos.\n\n+ Lean es un lenguaje de programación funcional. Lean se basa en la\n  teoría de tipos y en el cálculo de construcciones inductivas en lugar\n  de la teoría de conjuntos, ofrece la posibilidad de elegir entre la\n  lógica clásica y la intuicionista, y el cálculo de pruebas se basa en\n  el isomorfismo de Curry-Howard.\n  \n** Tipos\n\n+ El lenguaje de programación Lean es de tipo estático; es decir, todos\n  los términos están sujetos a reglas de tipado y sus tipos se declaran\n  o infieren en tiempo de compilación. \n\n+ Los tipos en Lean se pueden construir combinando los siguientes:\n  - Tipos de función (símbolo →): Si A y B son tipos, entonces A → B\n    denota el tipo de todas las funciones de A a B.\n  - Tipos de pares (símbolo ×): Si A y B son tipos, entonces A × B\n    denota el tipo de todos los pares con el primer componente del tipo\n    A y el segundo componente del tipo B.\n  - Tipos inductivos (palabra clave ~inductive~):\n    + Los tipos inductivos tienen una lista finita de constructores que\n      pueden depender recursivamente unos de otros.\n    + Ejemplos de tipos inductivos son los tipos de enumeración simple,\n      las listas de números naturales y los árboles.\n  - Tipos de registro (palabra clave ~structure~):\n    + Los tipos de registro tienen un único constructor sobre una lista\n      finita de campos.\n    + Se puede acceder a estos campos a través de las proyecciones\n      correspondientes.\n    + Ejemplos de tipos de registro son los tipos de pares o las\n      estructuras matemáticas combinadas que constan de múltiples\n      componentes o propiedades.\n    + Los registros en Lean son extensibles y, por tanto, pueden\n      utilizarse para construir teorías de forma jerárquica.\n  - Además, Lean tiene cierto soporte para subtipos y cocientes.\n\n+ Lean admite clases de tipo.\n  + Las clases de tipos (palabra clave ~class~ o ~@[class] structure~)\n    son una variante de los tipos de registro.\n  + Las clases de tipos pueden verse como la formalización de un\n    conjunto finito de axiomas sobre los tipos de parámetros dados.\n  + Dar una instancia de una clase de tipo corresponde a demostrar los\n    axiomas correspondientes sobre los tipos de parámetros.\n  + Las clases de tipos y sus instancias están sujetas a la\n    inferencia de clases de tipos.\n  + Ejemplos de clases de tipos son todo tipo de estructuras algebraicas\n    como monoides, grupos, etc. Análogamente, también las estructuras\n    métricas y los conceptos de la teoría de categorías se axiomatizan\n    mediante clases de tipos.\n  + Es posible definir múltiples instancias para la misma clase de tipos\n    sobre los mismos tipos de parámetros; matemáticamente, esto\n    corresponde a, por ejemplo definir múltiples estructuras de grupo\n    sobre el mismo conjunto.\n\n+ Tipos dependientes:\n  + Lean se basa en la teoría de tipos dependientes.\n  + Los tipos son ciudadanos de primera clase y los tipos de suma y\n    producto subyacentes a los tipos de función, tipos inductivos y\n    tipos de registro son sumas dependientes (tipos Sigma dependientes:\n    Σ) y productos (tipos Pi dependientes: Π).\n  + Lean admite restricciones y dependencias en los tipos de los\n    argumentos y en el del resultado resultado.\n\n+ Los tipos de Lean están organizados en una jerarquía:\n  + ~Prop~ (equivalentemente, ~Sort 0~) es la parte inferior de la\n    jerarquía de tipos.\n    + Las expresiones de tipo ~Prop~ se consideran \"proposiciones\".\n    + El tipo ~Prop~ contiene las constantes booleanas ~true~ y ~false~\n    + Las conectivas lógicas convierten los miembros del tipo ~Prop~ en\n      resultados del tipo ~Prop~.\n  + El ~Type u~ (equivalentemente, ~Sort (u+1)~), para un número natural\n    ~u~, pertenece a ~Type (u+1)~.\n  + ~Type~ es una abreviatura de ~Type 0~.\n  + ~Type*~ es una abreviatura para el ~Type u~ para algún nivel de\n    universo no especificado ~u~.\n  + Los constructores de tipos (como →) operan sobre estos universos de\n    tipos.\n\n+ Los términos de tipo ~Prop~ satisfacen la *extensionalidad\n  proposicional*: Si ~A : Prop~ y ~x, y : A~, entonces ~x~ e ~y~ se\n  consideran iguales en todos los aspectos.\n\n** Demostraciones\n\n+ En las pruebas matemáticas se usa el /modus ponens/:\n  + Si el enunciado ~A~ está demostrado y si la implicación ~A ⇒ B~ está demostrada, entonces\n    se deduce que también se demuestra ~B~.\n   \n+ El *isomorfismo Curry-Howard* identifica\n  - enunciados con tipos y\n  - pruebas de enunciados con elementos del tipo correspondiente.\n\n+ El /modus ponens/ corresponde a la aplicación de la función:\n  + Si ~x : A~  y ~f : A → B~, entonces ~f x : B~.\n\n+ Las pruebas en Lean son sólo implementaciones de funciones.\n  + Una prueba del lema\n    #+begin_src lean\nlemma primer_resultado\n  (x : A)\n  : ϕ x :=\nbegin\n...\nend\n    #+end_src\n    no es más que una implementación de una función del tipo ~Π (x : A), ϕ x~.\n\n+ [[./src/primer_ejemplo.lean][Primer ejemplo de demostración]] \n#+INCLUDE: \"./src/primer_ejemplo.lean\" src lean\n\n* Ejemplos básicos\n\n** Aplicaciones inyectivas y suprayectivas\n\n+ [[./src/aplicaciones.lean][Aplicaciones inyectivas, suprayectivas y biyectivas]] \n#+INCLUDE: \"./src/aplicaciones.lean\" src lean\n\n** Inducción\n\n+ [[./src/induccion.lean][Inducción]]\n#+INCLUDE: \"./src/induccion.lean\" src lean\n\n** Conmutadores\n\n+ [[./src/Conmutadores_en_grupos.lean][Conmutadores en grupos]]. \n#+INCLUDE: \"./src/Conmutadores_en_grupos.lean\" src lean\n   \n** El cero real\n\n** Ejercicios   \n\n* Opciones de diseño\n\n** Diseño recursivo\n\n** Complejos simpliciales\n\n** Aplicaciones simpliciales\n\n** Complejos simpliciales finitos\n\n** Generación de complejos simpliciales\n\n** Combinación de complejos simpliciales\n\n** La característica de Euler\n\n** Hacia una biblioteca\n\n** Ejercicios\n\n* Abstracción y prototipado\n\n** Formalización directa: Seminormas functoriales\n\n** Formalización indirecta: Multiplicidad susceptible\n\n\n   \n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjaalonso%2Fexplorando-con-lean","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjaalonso%2Fexplorando-con-lean","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjaalonso%2Fexplorando-con-lean/lists"}