Acciones

Diferencia entre revisiones de «T4»

De Lógica matemática y fundamentos [Curso 2019-20]

Línea 1: Línea 1:
 
<source lang = "isabelle">
 
<source lang = "isabelle">
theory T4_sol
+
text ‹Ejercicio 4 de Lógica Matemática y Fundamentos (26-mayo-2020)›
 +
 
 +
theory uvus
 
imports Main  
 
imports Main  
 
begin
 
begin
 +
 +
text ‹
 +
  Apellidos:
 +
  Nombre:
 +
 +
 +
text ‹Sustituye la palabra uvus por tu usuario de la Universidad de
 +
  Sevilla y graba el fichero con dicho usuario.thy›
 +
 +
text ‹Nota 1: El tiempo de realización del ejercicio, incluida su
 +
  entrega en la PEV, es de 15:30 a 16:30.›
 +
 +
text ‹Nota 2: El segundo ejercicio se realizará de 16:00 a 17:00,
 +
  estando disponible desde la PEV a partir de las 17:00 .›
 +
 +
text ‹Nota 3: Además de las reglas básicas de deducción natural de la
 +
  lógica proposicional y de primer orden, también se pueden usar las
 +
  reglas notnotI y mt que demostramos a  continuación.›
 +
 +
text ‹Nota 4: En el proceso de corrección del ejercicio, y antes de la
 +
  publicación de las calificaciones del mismo, se podrá requerir
 +
  aclaraciones sobre su respuesta. Estas aclaraciones se harán por
 +
  alguno de los procedimientos virtuales previstos en la PEV. ›
  
 
lemma notnotI: "P ⟹ ¬¬ P"
 
lemma notnotI: "P ⟹ ¬¬ P"
Línea 10: Línea 35:
 
   by auto
 
   by auto
  
text ‹-----------------------------------------------------------------
+
text ‹------------------------------------------------------------------
 
   Se define la función
 
   Se define la función
 
     elimina :: nat ⇒ 'a list ⇒ 'a list
 
     elimina :: nat ⇒ 'a list ⇒ 'a list
Línea 25: Línea 50:
 
text ‹------------------------------------------------------------------
 
text ‹------------------------------------------------------------------
 
   Ejercicio. Demostrar que  
 
   Ejercicio. Demostrar que  
     length (elimina n xs) ≤ length xs - n
+
     length (elimina n xs) ≤ length xs
 
   ---------------------------------------------------------------------›
 
   ---------------------------------------------------------------------›
  
‹Por inducción en n y xs según el esquema elimina.induct›
+
‹Demostración en lenguaje natural
 
 
― ‹Estructurada›
 
lemma  "length (elimina n xs) ≤ length xs"
 
proof(induct n xs rule :elimina.induct)
 
  show "⋀n. length (elimina n []) ≤ length []" by simp
 
  next
 
  show "⋀v va. length (elimina 0 (v # va)) ≤ length (v # va)"
 
  by simp
 
  next
 
  show "⋀n x xs.
 
      length (elimina n xs) ≤ length xs ⟹
 
      length (elimina (Suc n) (x # xs)) ≤ length (x # xs)"
 
      by simp
 
qed
 
 
 
― ‹Automática›
 
lemma  "length (elimina n xs) ≤ length xs"
 
  by (induct n xs rule :elimina.induct) simp_all
 
 
 
― ‹Declarativa detallada›
 
  
lemma  "length (elimina n xs) ≤ length xs"
+
proof(induct n xs rule :elimina.induct)
 
  fix n ::"nat"
 
  show "length (elimina n []) ≤ length []"
 
    by (simp only: elimina.simps(1) list.size(3))
 
next
 
  fix x::"'a" and xs::"'a list"
 
  show "length (elimina 0 (x # xs)) ≤ length (x #xs)"
 
    by (simp only: elimina.simps(2) list.size(2))
 
next
 
  fix n ::"nat" and x::"'a" and xs::"'a list"
 
  assume H:"length (elimina n xs) ≤ length xs"
 
  have "length(elimina (Suc n) (x#xs)) = length(elimina n xs)"
 
    by (simp only: elimina.simps(3))
 
  also have "… ≤ length xs"
 
    using H by (simp only:)
 
  also have "… ≤ length (x#xs)"
 
    by (simp only: list.size(4))
 
  finally show "length(elimina (Suc n) (x#xs)) ≤ length (x#xs)".
 
  qed
 
  
‹Aplicativa detallada›
+
‹Demostración detallada›
  
 
lemma  "length (elimina n xs) ≤ length xs"
 
lemma  "length (elimina n xs) ≤ length xs"
  apply (induct n xs rule :elimina.induct)
+
oops
  apply (simp only: elimina.simps(1))
 
  apply (simp only: elimina.simps(2))
 
  apply (simp only: elimina.simps(3))
 
  apply (simp only: list.size)
 
  done
 
 
 
  
― ‹Por inducción en n con xs arbitrario› 
 
  
― ‹Auxiliar›
 
lemma elimina0: "elimina 0 xs = xs"
 
  apply (cases xs)
 
  apply (simp only: elimina.simps(1))
 
  apply (simp only: elimina.simps(2))
 
  done
 
 
― ‹Estructurada› 
 
lemma "length (elimina n xs) ≤ length xs - n"
 
proof (induct n arbitrary: xs)
 
  show "⋀xs. length (elimina 0 xs) ≤ length xs - 0"
 
  by (simp only: elimina0)
 
  next
 
    fix n :: nat and xs :: "'a list"
 
  assume HI: "⋀xs:: 'a list. length (elimina n xs) ≤ length xs - n"
 
  show "length (elimina (Suc n) xs) ≤ length xs - (Suc n)"
 
  proof (cases xs)
 
  case Nil
 
  then show ?thesis by simp
 
  next
 
  case (Cons a list)
 
  then show ?thesis using HI by simp
 
  qed
 
qed
 
 
 
 
― ‹Declarativa detallada›
 
lemma "length (elimina n xs) ≤ length xs - n"
 
proof (induct n arbitrary: xs)
 
  fix xs :: "'a list"
 
  show "length (elimina 0 xs) ≤ length xs - 0"
 
    by (simp only: elimina0 list.size(3))
 
next
 
  fix n :: nat and xs :: "'a list"
 
  assume HI: "⋀xs:: 'a list. length (elimina n xs) ≤ length xs - n"
 
  show "length (elimina (Suc n) xs) ≤ length xs - (Suc n)"
 
  proof (cases xs)
 
    assume "xs = []"
 
    then have "elimina (Suc n) xs = elimina (Suc n) []"
 
      by (rule arg_cong)
 
    also have "… = []"
 
      by (simp only: elimina.simps(1))
 
    finally have "elimina (Suc n) xs = []"
 
      by this
 
    then have "length (elimina (Suc n) xs) = 0"
 
      by (simp only: list.size(3))
 
    then show "length (elimina (Suc n) xs) ≤ length xs - (Suc n)"
 
      by (simp only: list.size(3))
 
  next
 
    fix y:: "'a" and  ys :: "'a list"
 
    assume 1: "xs = y # ys"
 
    have 2: "length (elimina n ys) ≤ length ys - n"
 
      using HI by this
 
    have "length (elimina (Suc n) xs) = length (elimina (Suc n) (y#ys))"
 
      using 1 by (rule arg_cong)
 
    also have "… = length (elimina n ys)"
 
      by (simp only: elimina.simps(3))
 
    also have "… ≤  length ys - n"
 
      using 2 by (simp only:)
 
    also have "… = 1 + length ys - (Suc n)"
 
      by (simp only: diff_Suc_Suc)
 
    also have "… = length (y#ys) - (Suc n)"
 
      by (simp only: list.size(4))
 
    also have "… = length xs - (Suc n)"
 
      using 1 by (simp only: list.size(4))
 
    finally show "length (elimina (Suc n) xs) ≤ length xs - (Suc n)"
 
      by this   
 
  qed
 
qed
 
 
― ‹Aplicativa detallada›
 
 
lemma "length (elimina n xs) ≤ length xs - n"
 
  apply (induct n arbitrary: xs)
 
  apply (simp only: elimina0)
 
  apply (case_tac xs)
 
  apply (simp only: elimina.simps)
 
  apply (simp only: list.size(3))
 
  apply (simp only: elimina.simps(3))
 
  apply (simp only: list.size(4))
 
  apply (simp only: add_Suc_right)
 
  apply (simp only: add.right_neutral)
 
  apply (simp only: diff_Suc_Suc)
 
  done
 
 
― ‹Demostración por inducción en xs con n arbitrario›
 
 
― ‹Estructurada›
 
 
lemma  "length (elimina n xs) ≤ length xs"
 
proof (induct xs arbitrary: n)
 
  show "⋀n. length (elimina n []) ≤ length []" by simp
 
  next
 
  fix n::"nat" and x::'a and xs:: "'a list"
 
  assume HI: "  ⋀n. length (elimina n xs) ≤ length xs"
 
  show "length (elimina n (x# xs)) ≤ length (x#xs)"
 
  proof(cases n)
 
  case 0
 
  then show ?thesis by simp
 
  next
 
  case (Suc nat)
 
  then show ?thesis using HI
 
  by (metis elimina.simps(3) list.size(4) trans_le_add1)
 
  qed
 
  qed
 
 
― ‹Declarativa detallada›
 
 
lemma  "length (elimina n xs) ≤ length xs"
 
proof (induct xs arbitrary: n)
 
  fix n::"nat"
 
  show "length (elimina n []) ≤ length []"
 
    by (simp only: elimina.simps(1) list.size)
 
next
 
  fix n::"nat" and x::'a and xs:: "'a list"
 
  assume HI: "  ⋀n. length (elimina n xs) ≤ length xs"
 
  show "length (elimina n (x# xs)) ≤ length (x#xs)"
 
  proof(cases n)
 
    assume "n=0"
 
    then have "(elimina n (x# xs)) =(x#xs)"
 
      by (simp only: elimina.simps(2))
 
      then have "length (elimina n (x# xs)) = length (x#xs)" 
 
        by (rule arg_cong)
 
        then show  "length (elimina n (x# xs)) ≤ length (x#xs)"
 
          by (simp only: order_refl)
 
  next
 
    fix m:: nat
 
    assume "n=(Suc m)"
 
    then have "length (elimina n (x# xs)) =
 
              length (elimina (Suc m) (x# xs))"
 
                by (rule arg_cong)
 
    also have "… =length (elimina m xs)"
 
                by (simp only: elimina.simps(3))
 
    also have "… ≤ length xs" using HI by (simp only:)
 
    also have "… ≤ 1+length xs " by (simp only: le_add1)
 
    also have "…≤ length (x#xs)" by (simp only: list.size)
 
    finally show "length (elimina n (x# xs))≤length (x#xs)"
 
      by (simp only:)
 
  qed
 
  qed 
 
 
― ‹Aplicativa detallada›
 
 
lemma "length (elimina n xs) ≤ length xs - n"
 
  apply (induct xs arbitrary: n)
 
  apply (simp only: elimina.simps(1) list.size)
 
  apply (case_tac n)
 
  apply (simp only: elimina.simps(2) list.size)
 
  apply (simp only: elimina.simps(3) list.size)
 
  apply (simp only:add_Suc_right)
 
  apply (simp only:add.right_neutral)
 
  apply (simp only: diff_Suc_Suc)
 
  done
 
 
 
 
 
 
text ‹------------------------------------------------------------------  
 
text ‹------------------------------------------------------------------  
 
   Ejercicio 2. Demostrar que si se verifica  
 
   Ejercicio 2. Demostrar que si se verifica  
Línea 250: Línea 73:
 
   --------------------------------------------------------------------›
 
   --------------------------------------------------------------------›
  
― ‹Demostración declarativa detallada›
+
― ‹Demostración detallada›
 
 
lemma
 
    fixes P Q :: "'b ⇒ bool"
 
    assumes "∀x. ∃y. (P x ⟶ Q y)"
 
    shows  "∀x. (P x ⟶ (∃y. Q y))"
 
proof (rule allI)
 
  fix x
 
  show "P x ⟶ (∃y. Q y)"
 
  proof (rule impI)
 
    assume "P x"
 
    have " ∃y. (P x ⟶ Q y)"
 
      using assms by (rule allE)
 
    then obtain b where "P x ⟶ Q b"
 
      by (rule exE)
 
    then have "Q b"
 
      using ‹P x› by (rule mp)
 
    then show "∃y. Q y"
 
      by (rule exI)
 
  qed
 
qed
 
 
 
― ‹Demostración aplicativa detallada›
 
  
 
lemma  
 
lemma  
"∀x. (P x ⟶ (∃y. Q y)) ∀x. ∃y. (P x ⟶ Q y)"
+
  fixes P Q :: "'b ⇒ bool"
   apply(rule allI)
+
  assumes "∀x. (P x ⟶ (∃y. Q y))"
  apply(erule_tac x = x in allE)
+
  shows  "∀x. ∃y. (P x ⟶ Q y)"
  apply(case_tac "P x")
+
   oops
  apply(drule mp, assumption)
 
  apply(erule exE)
 
  apply (rule_tac x = y in exI)
 
  apply(rule impI, assumption)
 
  apply (rule exI)
 
  apply(rule impI)
 
  apply(erule notE, assumption)
 
  done
 
  
end  
+
end
</source
+
</source>

Revisión del 12:33 1 jun 2020

text Ejercicio 4 de Lógica Matemática y Fundamentos (26-mayo-2020)

theory uvus
imports Main 
begin

text 
  Apellidos:
  Nombre: 
 

text Sustituye la palabra uvus por tu usuario de la Universidad de
  Sevilla y graba el fichero con dicho usuario.thy 

text Nota 1: El tiempo de realización del ejercicio, incluida su
   entrega en la PEV, es de 15:30 a 16:30. 

text Nota 2: El segundo ejercicio se realizará de 16:00 a 17:00,
  estando disponible desde la PEV a partir de las 17:00 . 

text Nota 3: Además de las reglas básicas de deducción natural de la 
  lógica proposicional y de primer orden, también se pueden usar las 
  reglas notnotI y mt que demostramos a  continuación.

text Nota 4: En el proceso de corrección del ejercicio, y antes de la
  publicación de las calificaciones del mismo, se podrá requerir
  aclaraciones sobre su respuesta. Estas aclaraciones se harán por 
  alguno de los procedimientos virtuales previstos en la PEV. 

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

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

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

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

text ------------------------------------------------------------------
  Ejercicio. Demostrar que 
     length (elimina n xs)  length xs
  ---------------------------------------------------------------------

 Demostración en lenguaje natural



 Demostración detallada

lemma  "length (elimina n xs) ≤ length xs"
oops


text ------------------------------------------------------------------ 
  Ejercicio 2. Demostrar que si se verifica 
     x. (P x  (y. Q y))
  entonces se verifica 
     x. y. (P x  Q y)

  Nota: Hacer la demostración de forma detallada. Es opcional hacerla 
  de forma declarativa o aplicativa.
  --------------------------------------------------------------------

 Demostración detallada

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

end