Menu Close

Etiqueta: Isabelle/HOL

RA2017: Razonamiento estructurado sobre programas con Isabelle/HOL

En la clase de hoy del curso de Razonamiento automático se ha presentado cómo se puede demostrar propiedades de programas funcionales con Isabelle/HOL.

Para ello, se ha visto cómo representar en Isabelle/HOL las demostraciones de propiedades de programas estudiadas en el tema 8 del curso de Informática.

Los métodos de demostración utilizados son razonamiento ecuacional, inducción sobre los números naturales, inducción sobre listas e inducción sobre esquemas correspondientes a definiciones recursivas.

La teoría con los ejemplos presentados en la clase es la siguiente:

RA2017: Razonamiento automático sobre programas en Isabelle/HOL

En la segunda parte de la clase de hoy del curso de Razonamiento automático se han comenzado el estudio de la demostración automática de propiedades de programas funcionales en Isabelle/HOL.

En primer lugar, se ha estudiado cómo se pueden demostrar manualmente propiedades de programas Haskell. Para ello, se han usado las [transparencias del tema 8][http://www.cs.us.es/~jalonso/cursos/i1m-16/temas/tema-8.pdf) del curso de Informática (de 1º del Grado en Matemática). Como lectura complementaria se recomienda el capítulo 13 del libro de G. Hutton Programming in Haskell.

A continuación se ha explicado cómo demostrar automáticamente las propiedades anteriores con Isabelle/HOL.

El enunciado de las propiedades es inmediato: basta escribir la palabra lemma y a continuación la propiedad entre comillas dobles; por ejemplo,

lemma "longitud (repite n x) = n"

También se puede poner un nombre al lema, por ejemplo,

lemma inversaAcAux_es_inversa:
  "inversaAcAux xs ys = (inversa xs)@ys"

La demostración es la palabra by seguida por el método de demostración. Los métodos que hemos usado son

  • by simp: que es el método de simplificación por reescritura,
  • by (induct x) auto: que es por inducción en x (donde x es un número natural o una lista) y simplificación automática de ambos casos,
  • by (induct rule: fn.induct) auto: que es por inducción según la definición de la función fn y simplificación automática de todos los casos,
  • by (simp add: lema_auxiliar): que es el método de simplificación por reescritura añadiéndole a las reglas de reescritura la correspondiente al lema_auxiliar,

La teoría con los ejemplos presentados en la clase es la siguiente:

Como tarea se propuso la resolución de los ejercicios de la 2ª relación.

LMF2017: Deducción natural proposicional con Isabelle/HOL

En la segunda parte de la clase de hoy del curso Lógica matemática y fundamentos se ha continuado el estudio de la deducción natural en la lógica proposicional con Isabelle/HOL.

La teoría Isabelle correspondiente es

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
 
end

LMF2017: Deducción natural proposicional (2)

En la segunda parte de la clase de hoy del curso Lógica matemática y fundamentos se ha continuado el estudio de la deducción natural en la lógica proposicional.

Se han estudiado las siguientes reglas básicas

  • Regla de copia
  • Reglas de la negación
  • Reglas del bicondicional

y la siguientes reglas derivadas:

  • Regla del modus tollens
  • Regla de introducción de doble negación
  • Regla de reducción al absurdo
  • Ley del tercio excluido

Finalmente, se ha comentado la instalación de Isabelle y su uso para demostrar una fórmula con distinto nivel de detalle.

Las transparencias de esta clase son las 12-29 del tema 2 y la teoría Isabelle es

header {* Tema 2: Deducción natural proposicional con Isabelle/HOL *}
 
theory T2
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.
 
  La página al lado de cada ejemplo indica la página de las transparencias 
  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
 
end

RA2016: Deducción natural en lógica de primer orden con Isabelle/HOL

En la clase de hoy del curso de Razonamiento automático se ha presentado la deducción natural en lógica de primer orden con Isabelle/HOL. La presentación se basa en los ejemplos del tema 8 del curso de Lógica informática, que a su vez se basa en el capítulo 2 del libro de de Huth y Ryan Logic in Computer Science (Modelling and reasoning about systems).

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

Para cada ejemplo se presentan distintas demostraciones. La primera intenta reflejar la demostración de las transparencias, las siguientes van eliminando detalles de la prueba hasta la última que es automática.

A los largos de los ejemplos se van comentando los elementos del lenguaje conforme van entrando en el juego.

La teoría con los ejemplos presentados en la clase es la siguiente: