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

https://www.glc.us.es/~jalonso/RA2014/api.php?action=feedcontributions&feedformat=atom&user=Emimarriv Razonamiento automático (2014-15) - Contribuciones del usuario [es] 2026-07-18T04:50:48Z Contribuciones del usuario MediaWiki 1.31.14 https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_6&diff=162 Relación 6 2014-11-22T22:29:48Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R6: Sustitución, inversión y eliminación *}<br /> <br /> theory R6<br /> imports Main <br /> begin<br /> <br /> text {*<br /> Nota: En esta relación se pide hacer las demostraciones de forma <br /> automática. *} <br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> sust :: "'a ⇒ 'a ⇒ 'a list ⇒ 'a list"<br /> tal que (sust x y zs) es la lista obtenida sustituyendo cada<br /> occurrencia de x por y en la lista zs. Por ejemplo,<br /> sust (1::int) 2 [1,2,3,4,1,2,3,4] = [2,2,3,4,2,2,3,4]<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob, emimarriv"<br /> fun sust :: "'a ⇒ 'a ⇒ 'a list ⇒ 'a list" where<br /> "sust x y [] = []"<br /> |"sust x y (z#zs) = (if z = x then y#(sust x y zs) else z#(sust x y zs))"<br /> <br /> value "sust (1::int) 2 [1,2,3,4,1,2,3,4]" -- "= [2,2,3,4,2,2,3,4]"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Demostrar o refutar <br /> sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma sust_append: <br /> "sust x y (xs@ys) = (sust x y xs)@(sust x y ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3. Demostrar o refutar <br /> rev (sust x y zs) = sust x y (rev zs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma rev_sust: <br /> "rev(sust x y zs) = sust x y (rev zs)"<br /> by (induct zs, simp_all add: sust_append)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4. Demostrar o refutar:<br /> sust x y (sust u v zs) = sust u v (sust x y zs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sust x y (sust u v zs) = sust u v (sust x y zs)"<br /> quickcheck<br /> oops<br /> (*Encuentra el contraejemplo:<br /> x = a⇩1<br /> y = a⇩2<br /> u = a⇩2<br /> v = a⇩1<br /> zs = [a⇩1]<br /> *)<br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5. Demostrar o refutar:<br /> sust y z (sust x y zs) = sust x z zs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sust y z (sust x y zs) = sust x z zs"<br /> quickcheck<br /> oops<br /> (*Encuentra el contraejemplo:<br /> y = a⇩1<br /> z = a⇩2<br /> x = a⇩2<br /> zs = [a⇩1]<br /> *)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Definir la función<br /> borra :: "'a ⇒ 'a list ⇒ 'a list"<br /> tal que (borra x ys) es la lista obtenida borrando la primera<br /> ocurrencia del elemento x en la lista ys. Por ejemplo,<br /> borra (2::int) [1,2,3,2] = [1,3,2]<br /> <br /> Nota: La función borra es equivalente a la predefinida remove1. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> fun borra :: "'a ⇒ 'a list ⇒ 'a list" where<br /> "borra x [] = []"<br /> |"borra x (y#ys) = (if y=x then ys else y#borra x ys)"<br /> <br /> value "borra (2::int) [1,2,3,2]" -- "= [1,3,2]"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 7. Definir la función<br /> borraTodas :: "'a ⇒ 'a list ⇒ 'a list"<br /> tal que (borraTodas x ys) es la lista obtenida borrando todas las<br /> ocurrencias del elemento x en la lista ys. Por ejemplo,<br /> borraTodas (2::int) [1,2,3,2] = [1,3]<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> fun borraTodas :: "'a ⇒ 'a list ⇒ 'a list" where<br /> "borraTodas x [] = []"<br /> |"borraTodas x (y#ys) = (if y = x then borraTodas x ys <br /> else y#borraTodas x ys)"<br /> <br /> value "borraTodas (2::int) [1,2,3,2]" -- "= [1,3]"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8. Demostrar o refutar <br /> borra x (borraTodas x xs) = borraTodas x xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma l1: "borra x (borraTodas x xs) = borraTodas x xs"<br /> by (induct xs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9. Demostrar o refutar <br /> borraTodas x (borraTodas x xs) = borraTodas x xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "borraTodas x (borraTodas x xs) = borraTodas x xs"<br /> by (induct xs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Demostrar o refutar automáticamente<br /> borraTodas x (borra x xs) = borraTodas x xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma borraTodas_borra: <br /> "borraTodas x (borra x xs) = borraTodas x xs"<br /> by (induct xs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11. Demostrar o refutar <br /> borra x (borra y xs) = borra y (borra x xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "borra x (borra y xs) = borra y (borra x xs)"<br /> by (induct xs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Demostrar o refutar automáticamente<br /> borraTodas x (borra y xs) = borra y (borraTodas x xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "borraTodas x (borra y xs) = borra y (borraTodas x xs)"<br /> by (induct xs, simp_all add: l1)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Demostrar o refutar:<br /> borra y (sust x y xs) = borra x xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "borra y (sust x y xs) = borra x xs"<br /> quickcheck<br /> oops<br /> (* Encuentra el contraejemplo:<br /> y = a⇩1<br /> x = a⇩2<br /> xs = [a⇩1]<br /> *)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Demostrar o refutar:<br /> borraTodas y (sust x y xs) = borraTodas x xs"<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "borraTodas y (sust x y xs) = borraTodas x xs"<br /> quickcheck<br /> oops<br /> (* Encuentra el contraejemplo:<br /> y = a⇩1<br /> x = a⇩2<br /> xs = [a⇩1]<br /> *)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Demostrar o refutar <br /> sust x y (borraTodas x zs) = borraTodas x zs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sust x y (borraTodas x zs) = borraTodas x zs"<br /> by (induct zs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16. Demostrar o refutar<br /> sust x y (borraTodas z zs) = borraTodas z (sust x y zs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sust x y (borraTodas z zs) = borraTodas z (sust x y zs)"<br /> quickcheck<br /> oops<br /> (* Encuentra el contraejemplo:<br /> x = a⇩1<br /> y = a⇩2<br /> z = a⇩1<br /> zs = [a⇩1]<br /> *)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17. Demostrar o refutar:<br /> rev (borra x xs) = borra x (rev xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "rev (borra x xs) = borra x (rev xs)"<br /> quickcheck<br /> oops<br /> (* Encuentra el contraejemplo:<br /> x = a⇩1<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> *)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18. Demostrar o refutar <br /> borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma borraTodas_append:<br /> "borraTodas x (xs@ys) = (borraTodas x xs)@(borraTodas x ys)"<br /> by (induct xs, simp_all)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar <br /> rev (borraTodas x xs) = borraTodas x (rev xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "rev (borraTodas x xs) = borraTodas x (rev xs)"<br /> by (induct xs, simp_all add: borraTodas_append)<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=134 Relación 5 2014-11-17T21:21:58Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> -- "emimarriv"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (x#xs)) = algunos P ((rev xs)@[x])" by simp<br /> also have "... = (algunos P (rev xs) ∨ (P x))" by (auto simp add: algunos_append)<br /> also have "... = (algunos P xs ∨ (P x))" using HI by simp<br /> finally show " algunos P (rev (x#xs)) = algunos P (x#xs)" by auto<br /> qed<br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> --"emimarriv"<br /> fun sinDuplicados3 :: "'a list ⇒ bool" where<br /> "sinDuplicados3 [] = True"<br /> | "sinDuplicados3 (x#xs) = (if estaEn x xs then False else sinDuplicados3 xs )"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=133 Relación 5 2014-11-17T17:48:04Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> -- "emimarriv"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (x#xs)) = algunos P ((rev xs)@[x])" by simp<br /> also have "... = (algunos P (rev xs) ∨ (P x))" by (auto simp add: algunos_append)<br /> also have "... = (algunos P xs ∨ (P x))" using HI by simp<br /> finally show " algunos P (rev (x#xs)) = algunos P (x#xs)" by auto<br /> qed<br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=132 Relación 5 2014-11-17T17:36:24Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=131 Relación 5 2014-11-17T17:23:32Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=130 Relación 5 2014-11-17T16:28:34Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=129 Relación 5 2014-11-17T16:27:23Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob, emimarriv"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> <br /> -- "javrodviv1"<br /> (* A mi no me encuentra contraejemplo así que decidí probarlo pero me<br /> atasque, dejo mi demostración hasta donde estoy atascado*)<br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> have "algunos (λx. P x ∧ Q x) (a # xs) = ((P a) ∧ (Q a) ∨ algunos (λx. P x ∧ Q x) xs)" <br /> by simp<br /> also have "... = (((P a) ∧ (Q a)) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp<br /> oops<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=128 Relación 5 2014-11-17T15:45:21Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> <br /> -- "javrodviv1"<br /> (* A mi no me encuentra contraejemplo así que decidí probarlo pero me<br /> atasque, dejo mi demostración hasta donde estoy atascado*)<br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> have "algunos (λx. P x ∧ Q x) (a # xs) = ((P a) ∧ (Q a) ∨ algunos (λx. P x ∧ Q x) xs)" <br /> by simp<br /> also have "... = (((P a) ∧ (Q a)) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp<br /> oops<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=127 Relación 5 2014-11-17T14:50:53Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1, emimarriv"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> <br /> -- "javrodviv1"<br /> (* A mi no me encuentra contraejemplo así que decidí probarlo pero me<br /> atasque, dejo mi demostración hasta donde estoy atascado*)<br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> have "algunos (λx. P x ∧ Q x) (a # xs) = ((P a) ∧ (Q a) ∨ algunos (λx. P x ∧ Q x) xs)" <br /> by simp<br /> also have "... = (((P a) ∧ (Q a)) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp<br /> oops<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=126 Relación 5 2014-11-17T12:05:32Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1,juacorvic"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith <br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp <br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "juacorvic" (*Muy parecida a la solución anterior*)<br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x # xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have "... = ((P x ∧ Q x) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = (P x ∧ Q x ∧ todos P xs ∧ todos Q xs)" by simp<br /> also have "... = ((P x ∧ todos P xs) ∧ (Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x # xs) = (todos P (x # xs) ∧ todos Q (x # xs))" by simp<br /> qed<br /> <br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> --"emimarriv"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs) <br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs <br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) =((todos (λx. P x ∧ Q x) [x]) ∧ (todos (λx. P x ∧ Q x) xs))" by simp<br /> also have "... = ((todos P [x] ∧ todos Q [x]) ∧ (todos P xs ∧ todos Q xs))" using HI by simp<br /> also have "... = ((todos P [x] ∧ todos P xs) ∧ (todos Q [x] ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp (* emimarriv: Esta linea puede suprimirse, pero la dejo porque se sigue<br /> mejor el proceso*)<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = (todos P (x#xs) ∧ todos Q (x#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1,juacorvic"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> -- "juacorvic" <br /> (* es igual que las anteriores pero salió con mayor nivel de detalle *)<br /> <br /> lemma todos_append: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x <br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)" <br /> have "todos P ((a # x) @ y) = (P a ∧ todos P (x @ y))" by simp<br /> also have "... = (P a ∧ (todos P x ∧ todos P y))" using HI by simp<br /> also have "... = ((P a ∧ todos P x) ∧ todos P y)" by simp<br /> also have "... = (todos P (a # x) ∧ todos P y)" by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> <br /> -- "javrodviv1"<br /> (* A mi no me encuentra contraejemplo así que decidí probarlo pero me<br /> atasque, dejo mi demostración hasta donde estoy atascado*)<br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> have "algunos (λx. P x ∧ Q x) (a # xs) = ((P a) ∧ (Q a) ∨ algunos (λx. P x ∧ Q x) xs)" <br /> by simp<br /> also have "... = (((P a) ∧ (Q a)) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp<br /> oops<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_5&diff=120 Relación 5 2014-11-16T22:44:33Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R5: Cuantificadores sobre listas *}<br /> <br /> theory R5<br /> imports Main <br /> begin<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir la función <br /> todos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (todos p xs) se verifica si todos los elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> todos (λx. 1<length x) [[2,1,4],[1,3]]<br /> ¬todos (λx. 1<length x) [[2,1,4],[3]]<br /> <br /> Nota: La función todos es equivalente a la predefinida list_all. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1"<br /> fun todos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos p [] = True"<br /> |"todos p (x#xs) = (p x ∧ todos p xs)"<br /> <br /> --"jeshorcob"<br /> fun todos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos2 p xs = foldr (λx. op ∧ (p x)) xs True"<br /> <br /> --"emimarriv"<br /> fun todos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "todos3 p [] = True"<br /> | "todos3 p (x#xs) = (if p x then (todos3 p xs) else False)"<br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Definir la función <br /> algunos :: ('a ⇒ bool) ⇒ 'a list ⇒ bool<br /> tal que (algunos p xs) se verifica si algunos elementos de la lista <br /> xs cumplen la propiedad p. Por ejemplo, se verifica <br /> algunos (λx. 1<length x) [[2,1,4],[3]]<br /> ¬algunos (λx. 1<length x) [[],[3]]"<br /> <br /> Nota: La función algunos es equivalente a la predefinida list_ex. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (* Errata. Debe ser False el caso base seguro porque si no,<br /> la función devuelve siempre True*)<br /> --"jeshorcob,javrodviv1"<br /> fun algunos :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos p [] = False"<br /> |"algunos p (x#xs) = (p x ∨ algunos p xs)"<br /> <br /> --"jeshorcob"<br /> fun algunos2 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos2 p xs = foldr (λx. op ∨ (p x)) xs False"<br /> <br /> value "algunos (λx. x>10) [3::int,2]"<br /> value "algunos2 (λx. x>10) [3::int,2]"<br /> <br /> -- "javrodviv1"<br /> fun algunos3 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos3 p [] = False"<br /> |"algunos3 p (x#xs) = (p x ∨ todos p xs)"<br /> (* Nota. Nos da igual que sea True o False, pero para una proposición<br /> de más a delante necesitamos que sea False*)<br /> (* jeshorcob: Debe ser False y la función tiene una errata en<br /> la segunda linea porque la recursión la debe hacer sobre la función <br /> algunos3 en lugar de todos *)<br /> <br /> --"emimarriv"<br /> fun algunos4 :: "('a ⇒ bool) ⇒ 'a list ⇒ bool" where<br /> "algunos4 p [] =False"<br /> | "algunos4 p (x#xs) = (if p x then True else (algunos4 p xs))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.1. Demostrar o refutar automáticamente <br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1" <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3.2. Demostrar o refutar detalladamente<br /> todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> <br /> lemma "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (x#xs) = <br /> ((P x ∧ Q x) ∧ todos (λx. P x ∧ Q x) xs) " by simp<br /> also have "... = (P x∧Q x∧todos P xs∧todos Q xs)" using HI by simp<br /> also have "... = ((P x∧todos P xs)∧(Q x ∧ todos Q xs))" by arith<br /> also have "... = (todos P (x#xs) ∧ (Q x ∧ todos Q xs))" by simp<br /> also have "... = (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> finally show "todos (λx. P x ∧ Q x) (x#xs) = <br /> (todos P (x#xs) ∧ todos Q (x#xs))" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> <br /> lemma todo_append:<br /> "todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> proof (induct xs)<br /> show "todos (λx. P x ∧ Q x) [] = (todos P [] ∧ todos Q [])" by simp<br /> next <br /> fix a xs<br /> assume HI:"todos (λx. P x ∧ Q x) xs = (todos P xs ∧ todos Q xs)"<br /> have "todos (λx. P x ∧ Q x) (a # xs) = (((P a) ∧ (Q a)) ∧ todos (λx. P x ∧ Q x) xs)" by simp<br /> also have " ... = ((P a) ∧ (Q a) ∧ todos P xs ∧ todos Q xs)" using HI by simp<br /> finally show "todos (λx. P x ∧ Q x) (a # xs) = (todos P (a # xs) ∧ todos Q (a # xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.1. Demostrar o refutar automáticamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob,javrodviv1"<br /> lemma "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> by (induct x) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4.2. Demostrar o refutar detalladamente<br /> todos P (x @ y) = (todos P x ∧ todos P y)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma todos_append:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next<br /> fix a x<br /> assume HI: "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a#x)@y) = (P a ∧ todos P (x@y))" by simp<br /> also have "... = (P a ∧ todos P x ∧ todos P y)" using HI by simp<br /> also have "... = (todos P (a#x) ∧ todos P y)" by simp<br /> finally show "todos P ((a#x)@y) =<br /> (todos P (a#x) ∧ todos P y)" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> (* es igual que la de jeshorcob pero nos podemos ahorrar <br /> una linea de comando*)<br /> <br /> lemma todos_append2:<br /> "todos P (x @ y) = (todos P x ∧ todos P y)"<br /> proof (induct x)<br /> show "todos P ([] @ y) = (todos P [] ∧ todos P y)" by simp<br /> next <br /> fix a x<br /> assume HI:"todos P (x @ y) = (todos P x ∧ todos P y)"<br /> have "todos P ((a # x) @ y) = ((P a) ∧ todos P (x @ y))" by simp<br /> also have " ... = ((P a) ∧ todos P x ∧ todos P y)" using HI by simp<br /> finally show "todos P ((a # x) @ y) = (todos P (a # x) ∧ todos P y)" <br /> by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.1. Demostrar o refutar automáticamente <br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> apply (induct xs)<br /> apply (auto simp add: todos_append)<br /> done<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs"<br /> by (induct xs) (auto simp add: todos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5.2. Demostrar o refutar detalladamente<br /> todos P (rev xs) = todos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "todos P (rev xs) = todos P xs"<br /> proof (induct xs)<br /> show "todos P (rev []) = todos P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "todos P (rev xs) = todos P xs"<br /> have "todos P (rev (x#xs)) = todos P ((rev xs) @ [x])" by simp<br /> also have "... = (todos P (rev xs) ∧ todos P [x])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [x])" using HI by simp<br /> also have "... = (todos P xs ∧ P x)" by simp<br /> also have "... = (P x ∧ todos P xs)" by arith<br /> also have "... = todos P (x#xs)" by simp<br /> finally show "todos P (rev (x#xs)) = todos P (x#xs)" by simp<br /> qed<br /> <br /> -- "javrodviv1"<br /> <br /> lemma "todos P (rev xs) = todos P xs" <br /> proof (induct xs)<br /> show " todos P (rev []) = todos P []" by simp<br /> next<br /> fix a xs<br /> assume HI: "todos P (rev xs) = todos P xs "<br /> have "todos P (rev (a # xs)) = todos P ((rev xs) @ [a])" by simp<br /> also have " ... = (todos P (rev xs) ∧ todos P [a])" <br /> by (simp add: todos_append)<br /> also have "... = (todos P xs ∧ todos P [a])" using HI by simp<br /> finally show " todos P (rev (a # xs)) = todos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 6. Demostrar o refutar:<br /> algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: No sé cómo has conseguido el contraejemplo,<br /> probablemente algún fallo en los paréntesis, ya que la propiedad <br /> resulta cierta como expongo abajo:<br /> *)<br /> (* jeshorcob: el contraejemplo existe. Fijate en lo siguiente: *)<br /> fun p1 :: "int ⇒ bool" where<br /> "p1 x = (x=3)"<br /> fun q1 :: "int ⇒ bool" where<br /> "q1 x = (x=2)"<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2]" -- "= False <br /> (porque ningún elemento de la lista cumple a la vez p1 y q1)"<br /> value "(algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= True <br /> (porque cada elemento de la lista cumple una sola de p1 y q1)"<br /> (*Por tanto:*)<br /> value "algunos (λx. p1 x ∧ q1 x) [3,2] = <br /> (algunos p1 [3,2] ∧ algunos q1 [3,2])" -- "= False"<br /> (*Esta es una instancia del contraejemplo que encuentra QuickCheck*)<br /> <br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> by (metis (full_types) algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Al cambiar la definición de algunos para que coincida con list_ex es cierto el <br /> contraejemplo de Jesús<br /> *)<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> P = {a⇩1}<br /> Q = {a⇩2}<br /> xs = [a⇩1, a⇩2]<br /> *}<br /> <br /> <br /> -- "javrodviv1"<br /> (* A mi no me encuentra contraejemplo así que decidí probarlo pero me<br /> atasque, dejo mi demostración hasta donde estoy atascado*)<br /> <br /> lemma "algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∧ Q x) [] = (algunos P [] ∧ algunos Q [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos (λx. P x ∧ Q x) xs = (algunos P xs ∧ algunos Q xs)"<br /> have "algunos (λx. P x ∧ Q x) (a # xs) = ((P a) ∧ (Q a) ∨ algunos (λx. P x ∧ Q x) xs)" <br /> by simp<br /> also have "... = (((P a) ∧ (Q a)) ∨ (algunos P xs ∧ algunos Q xs))" using HI by simp<br /> oops<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.1. Demostrar o refutar automáticamente <br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 7.2. Demostrar o refutar datalladamente<br /> algunos P (map f xs) = algunos (P ∘ f) xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> <br /> lemma "algunos P (map f xs) = algunos (P o f) xs"<br /> proof (induct xs)<br /> show " algunos P (map f []) = algunos (P ∘ f) []" by simp<br /> next <br /> fix a xs<br /> assume HI: "algunos P (map f xs) = algunos (P ∘ f) xs"<br /> have "algunos P (map f (a # xs)) = ((P (f a)) ∨ algunos P (map f xs))" by simp<br /> also have " ... = (((P ∘ f) a) ∨ algunos (P ∘ f) xs)" using HI by simp<br /> finally show " algunos P (map f (a # xs)) = algunos (P ∘ f) (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.1. Demostrar o refutar automáticamente <br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> (*Pedrosrei: Pongo la automática que parece se os resiste.*) <br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (metis algunos.simps(1) algunos.simps(2) list_nonempty_induct)<br /> <br /> (*Si corregís la definición de algunos sería: *)<br /> <br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs, auto)<br /> <br /> (*jeshorcob: Pedro, a la tuya no sé que le pasa que no me la coge bien. <br /> Dejo la mía *)<br /> --"jeshorcob"<br /> lemma "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 8.2. Demostrar o refutar detalladamente<br /> algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma algunos_append:<br /> "algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> proof (induct xs)<br /> show "algunos P ([] @ ys) = (algunos P [] ∨ algunos P ys)" by simp<br /> next <br /> fix a xs<br /> assume HI:"algunos P (xs @ ys) = (algunos P xs ∨ algunos P ys)"<br /> have "algunos P ((a # xs) @ ys) = ((P a) ∨ algunos P (xs@ys))" by simp<br /> also have "... = ((P a) ∨ (algunos P xs ∨ algunos P ys))" <br /> using HI by simp<br /> finally show "algunos P ((a # xs) @ ys) = <br /> (algunos P (a # xs) ∨ algunos P ys)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.1. Demostrar o refutar automáticamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> by (induct xs) (auto simp add: algunos_append)<br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 9.2. Demostrar o refutar detalladamente<br /> algunos P (rev xs) = algunos P xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P (rev xs) = algunos P xs"<br /> proof (induct xs)<br /> show "algunos P (rev []) = algunos P []" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P (rev xs) = algunos P xs"<br /> have "algunos P (rev (a # xs)) = algunos P (rev xs @[a])" by simp<br /> also have "... = (algunos P xs ∨ (P a))" using HI using algunos_append by auto<br /> finally show " algunos P (rev (a # xs)) = algunos P (a # xs)" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 10. Encontrar un término no trivial Z tal que sea cierta la <br /> siguiente ecuación:<br /> algunos (λx. P x ∨ Q x) xs = Z<br /> y demostrar la equivalencia de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> proof (induct xs)<br /> show "algunos (λx. P x ∨ Q x) [] = (algunos P [] ∨ algunos Q [])" by simp<br /> next<br /> fix x xs<br /> assume hi:"algunos (λx. P x ∨ Q x) xs = (algunos P xs ∨ algunos Q xs)"<br /> have "algunos (λx. P x ∨ Q x) (x # xs) = ((P x ∨ Q x) <br /> ∨ algunos (λx. P x ∨ Q x) xs)" by simp<br /> also have "... = ((P x ∨ Q x) ∨ (algunos P xs ∨ algunos Q xs))" <br /> using hi by simp<br /> also have "... = (P x ∨ algunos P xs ∨ Q x ∨ algunos Q xs)" by arith<br /> finally show " algunos (λx. P x ∨ Q x) (x # xs) =<br /> (algunos P (x # xs) ∨ algunos Q (x # xs))" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.1. Demostrar o refutar automáticamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: Es falso.<br /> <br /> Por ejemplo P= esVacio, xs = []. P es la propiedad de ser vacío<br /> con nuestra construcción de algunos es cierto "algunos esVacio []"<br /> Sin embargo, todos (λx. (¬ esVacio {})) [] es lo mismo que <br /> todos _ [] = True, por lo que ¬(todos (λx. (¬ esVacio {})) []) = False,<br /> siendo falsa nuestra definición. Podemos coger de todas maneras la propiedad<br /> que queramos y sigue siendo falso porque <br /> (algunos _ [] True) ∧ (¬(todos _ [])= False)<br /> *)<br /> lemma <br /> shows "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> quickcheck<br /> oops<br /> (*Al corregir la definición de "algunos" deja de ser cierto lo dicho y <br /> correcto lo de abajo.<br /> *)<br /> <br /> (*jeshorcob: está claro que el fallo en todo era la definición esa*)<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> by (induct xs) auto<br /> <br /> <br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 11.2. Demostrar o refutar datalladamente<br /> algunos P xs = (¬ todos (λx. (¬ P x)) xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob"<br /> lemma "algunos P xs = (¬ todos (λx. (¬ P x)) xs)"<br /> proof (induct xs)<br /> show " algunos P [] = (¬ todos (λx. ¬ P x) [])" by simp<br /> next<br /> fix a xs<br /> assume HI:"algunos P xs = (¬ todos (λx. ¬ P x) xs)"<br /> have "algunos P (a # xs) = ((P a) ∨ algunos P xs)" by simp<br /> also have "... = ((P a) ∨ (¬ todos (λx. ¬ P x) xs))" using HI by simp<br /> finally show "algunos P (a # xs) =(¬ todos (λx. ¬ P x) (a#xs))" by auto<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 12. Definir la funcion primitiva recursiva <br /> estaEn :: 'a ⇒ 'a list ⇒ bool<br /> tal que (estaEn x xs) se verifica si el elemento x está en la lista<br /> xs. Por ejemplo, <br /> estaEn (2::nat) [3,2,4] = True<br /> estaEn (1::nat) [3,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun estaEn :: "'a ⇒ 'a list ⇒ bool" where<br /> "estaEn x [] = False"<br /> | "estaEn x (a#xs) = ((x=a) ∨ estaEn x xs)"<br /> <br /> value "estaEn (2::nat) [3,2,4]" --"= True"<br /> value "estaEn (1::nat) [3,2,4]" --"= False"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 13. Expresar la relación existente entre estaEn y algunos. <br /> Demostrar dicha relación de forma automática y detallada.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "algunos (λx. x=y) xs = estaEn y xs" (is "?P xs")<br /> proof (induct xs)<br /> show "?P []" by simp<br /> next<br /> fix x xs<br /> assume HI: "?P xs"<br /> have "estaEn y (x#xs) = (y=x ∨ estaEn y xs)" by simp<br /> also have "… = (y=x ∨ algunos (λx. (x=y)) xs)" using HI by simp<br /> finally show "?P (x#xs)" by auto<br /> qed<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 14. Definir la función primitiva recursiva <br /> sinDuplicados :: 'a list ⇒ bool<br /> tal que (sinDuplicados xs) se verifica si la lista xs no contiene<br /> duplicados. Por ejemplo, <br /> sinDuplicados [1::nat,4,2] = True<br /> sinDuplicados [1::nat,4,2,4] = False<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1"<br /> fun sinDuplicados :: "'a list ⇒ bool" where<br /> "sinDuplicados [] = False"<br /> | "sinDuplicados (x#xs) = (estaEn x xs ∨ sinDuplicados xs)"<br /> <br /> (*jeshorcob: Esta definición no es correcta. Véanse:*)<br /> value "sinDuplicados [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados [1::nat,4,2,4]" -- "= False"<br /> <br /> --"jeshorcob"<br /> fun sinDuplicados2 :: "'a list ⇒ bool" where<br /> "sinDuplicados2 [] = True"<br /> |"sinDuplicados2 (x#xs) = (¬(estaEn x xs) ∧ sinDuplicados2 xs)"<br /> <br /> value "sinDuplicados2 [1::nat,4,2]" -- "= True"<br /> value "sinDuplicados2 [1::nat,4,2,4]" -- "= False"<br /> <br /> text {* <br /> --------------------------------------------------------------------- <br /> Ejercicio 15. Definir la función primitiva recursiva <br /> borraDuplicados :: 'a list ⇒ bool<br /> tal que (borraDuplicados xs) es la lista obtenida eliminando los<br /> elementos duplicados de la lista xs. Por ejemplo, <br /> borraDuplicados [1::nat,2,4,2,3] = [1,4,2,3]<br /> <br /> Nota: La función borraDuplicados es equivalente a la predefinida <br /> remdups. <br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> fun borraDuplicados :: "'a list ⇒ 'a list" where<br /> "borraDuplicados [] = []"<br /> | "borraDuplicados (x#xs) = (if estaEn x xs then borraDuplicados xs else (x#(borraDuplicados xs)))"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.1. Demostrar o refutar automáticamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma "length (borraDuplicados xs) ≤ length xs"<br /> by (induct xs) auto<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 16.2. Demostrar o refutar detalladamente<br /> length (borraDuplicados xs) ≤ length xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1, jeshorcob" <br /> lemma length_borraDuplicados:<br /> "length (borraDuplicados xs) ≤ length xs"<br /> proof (induct xs)<br /> show "length (borraDuplicados []) ≤ length []" by simp<br /> next<br /> fix a xs<br /> assume HI:"length (borraDuplicados xs) ≤ length xs"<br /> have "length (borraDuplicados (a#xs))≤length (a#borraDuplicados xs)" by simp<br /> also have "... = 1+ length (borraDuplicados xs)" by simp<br /> also have "... ≤ 1+ length xs" using HI by simp<br /> finally show "length (borraDuplicados (a # xs)) ≤ length (a # xs)" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.1. Demostrar o refutar automáticamente <br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "javrodviv1" <br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> by (induct xs) auto<br /> <br /> --"jeshorcob"<br /> lemma "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> apply (induct xs, auto)<br /> done<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 17.2. Demostrar o refutar detalladamente<br /> estaEn a (borraDuplicados xs) = estaEn a xs<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> <br /> (*Pedrosrei: con esta definición de borraDuplicados es falso si cogemos<br /> xs= []. Además del quickcheck, podemos hacer "apply (induct xs, auto)" <br /> y ver que nos pide que demostremos False.<br /> *)<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> oops<br /> <br /> <br /> (*jeshorcob: dejo la prueba por inducción y casos*)<br /> --"jeshorcob"<br /> lemma estaEn_borraDuplicados: <br /> "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> proof (induct xs)<br /> show "estaEn a (borraDuplicados []) = estaEn a []" by simp<br /> next<br /> fix x xs<br /> assume hi: "estaEn a (borraDuplicados xs) = estaEn a xs"<br /> show "estaEn a (borraDuplicados (x#xs)) = estaEn a (x#xs)"<br /> proof (cases)<br /> assume a1:"estaEn x xs"<br /> then have "estaEn a (borraDuplicados (x#xs)) = <br /> estaEn a (borraDuplicados xs)" by simp<br /> also have "... = estaEn a xs" using hi by simp<br /> also have "... = estaEn a (x#xs)" using a1 by auto<br /> finally show ?thesis by simp<br /> next<br /> assume a2:"¬(estaEn x xs)"<br /> then have "estaEn a (borraDuplicados (x#xs)) =<br /> estaEn a (x#borraDuplicados xs)" by simp<br /> also have "... = (a = x ∨ estaEn a (borraDuplicados xs))" by simp<br /> finally show ?thesis using hi by simp<br /> qed<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.1. Demostrar o refutar automáticamente <br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma "sinDuplicados2 (borraDuplicados xs)"<br /> by (induct xs) (auto simp add: estaEn_borraDuplicados)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 18.2. Demostrar o refutar detalladamente<br /> sinDuplicados (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> --"jeshorcob"<br /> lemma sinDuplicados_borraDuplicados:<br /> "sinDuplicados2 (borraDuplicados xs)"<br /> proof (induct xs)<br /> show "sinDuplicados2 (borraDuplicados [])" by simp<br /> next<br /> fix x::"'a"<br /> fix xs::"'a list"<br /> assume hi: "sinDuplicados2 (borraDuplicados xs)"<br /> have "sinDuplicados2 (borraDuplicados (x#xs)) =<br /> sinDuplicados2 ((if estaEn x xs then borraDuplicados xs <br /> else x # borraDuplicados xs))" by simp<br /> also have "... = (if estaEn x xs <br /> then sinDuplicados2 (borraDuplicados xs) <br /> else sinDuplicados2 (x#borraDuplicados xs))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs)<br /> else (¬estaEn x (borraDuplicados xs) <br /> ∧ sinDuplicados2 (borraDuplicados xs)))" by simp<br /> also have "...= (if estaEn x xs then sinDuplicados2 (borraDuplicados xs) <br /> else (¬estaEn x xs ∧ sinDuplicados2 (borraDuplicados xs)))"<br /> by (simp add: estaEn_borraDuplicados)<br /> then show "sinDuplicados2 (borraDuplicados (x#xs))" <br /> using hi by (simp add: estaEn_borraDuplicados)<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 19. Demostrar o refutar:<br /> borraDuplicados (rev xs) = rev (borraDuplicados xs)<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> (*Pedrosrei: es falso, como podemos ver si cogemos [1,2,1] y evaluamos:<br /> *)<br /> lemma "borraDuplicados' (rev xs) = rev (borraDuplicados' xs)"<br /> quickcheck<br /> oops<br /> <br /> --"jeshorcob"<br /> lemma "borraDuplicados (rev xs) = rev (borraDuplicados xs)"<br /> quickcheck<br /> oops<br /> <br /> text {* Encuentra el contraejemplo<br /> xs = [a⇩1, a⇩2, a⇩1]<br /> Evaluated terms:<br /> borraDuplicados (rev xs) = [a⇩2, a⇩1]<br /> rev (borraDuplicados xs) = [a⇩1, a⇩2]<br /> *}<br /> <br /> end<br /> </source></div>

Emimarriv https://www.glc.us.es/~jalonso/RA2014/index.php?title=Relaci%C3%B3n_4&diff=119 Relación 4 2014-11-16T20:57:40Z

<p>Emimarriv: </p> <hr /> <div><source lang="isar"><br /> header {* R4: Cons inverso *}<br /> <br /> theory R4<br /> imports Main <br /> begin<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 1. Definir recursivamente la función <br /> snoc :: "'a list ⇒ 'a ⇒ 'a list"<br /> tal que (snoc xs a) es la lista obtenida al añadir el elemento a al<br /> final de la lista xs. Por ejemplo, <br /> value "snoc [2,5] (3::int)" == [2,5,3]<br /> <br /> Nota: No usar @.<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "davoremar,javrodviv1, jeshorcob, emimarriv"<br /> <br /> fun snoc :: "'a list ⇒ 'a ⇒ 'a list" where<br /> "snoc [] a = [a]"<br /> | "snoc (x#xs) a = x # (snoc xs a)"<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 2. Demostrar automáticamente el siguiente teorema <br /> snoc xs a = xs @ [a]<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "davoremar,javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma "snoc xs a = xs @ [a]"<br /> by (induct xs) auto<br /> <br /> (*Pedrosrei:no hace falta usar auto, sirve simp_all*)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 3. Demostrar detalladamente el siguiente teorema <br /> snoc xs a = xs @ [a]<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "davoremar,javrodviv1, jeshorcob, emimarriv"<br /> <br /> lemma snoc_append: "snoc xs a = xs @ [a]"<br /> proof (induct xs)<br /> show "snoc [] a = [] @ [a]" by simp<br /> next<br /> fix x xs<br /> assume HI: "snoc xs a = xs @ [a]"<br /> have "snoc (x#xs) a = x # (snoc xs a)" by simp<br /> also have "... = x # (xs @ [a])" using HI by simp<br /> finally show "snoc (x#xs) a = (x#xs) @ [a]" by simp<br /> qed<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 4. Demostrar automáticamente el siguiente lema<br /> rev (x # xs) = snoc (rev xs) x"<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "davoremar,javrodviv1, jeshorcob"<br /> <br /> lemma "rev (x # xs) = snoc (rev xs) x"<br /> by (auto simp add: snoc_append)<br /> <br /> (*Pedrosrei:no hace falta usar auto, sirve simp*)<br /> <br /> text {*<br /> --------------------------------------------------------------------- <br /> Ejercicio 5. Demostrar detalladamente el siguiente lema<br /> rev (x # xs) = snoc (rev xs) x"<br /> --------------------------------------------------------------------- <br /> *}<br /> <br /> -- "davoremar,javrodviv1, jeshorcob"<br /> <br /> lemma "rev (x # xs) = snoc (rev xs) x"<br /> proof -<br /> have "rev (x # xs) = (rev xs) @ [x]" by simp<br /> also have "... = snoc (rev xs) x" by (simp add:snoc_append)<br /> finally show "rev (x # xs) = snoc (rev xs) x" by simp<br /> qed<br /> <br /> end<br /> </source></div>

Emimarriv