https://www.glc.us.es/~jalonso/RA2013/api.php?action=feedcontributions&feedformat=atom&user=Diecabmen1
Razonamiento automático (2013-14) - Contribuciones del usuario [es]
2026-07-18T04:07:51Z
Contribuciones del usuario
MediaWiki 1.31.14
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=538
Relación 12
2014-02-11T01:42:32Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
--"diecabmen1"<br />
lemma correccion_valorM2:<br />
"valorM i m = valorF i (formM m)" (is "?P i m")<br />
proof (induct m)<br />
show "?P i []" by simp<br />
next<br />
fix a m<br />
assume HI: "?P i m"<br />
then show "?P i (a#m)" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP [] = Xor T T"<br />
| "formP (x#xs) = Xor (formM x) (formP xs)"<br />
<br />
value "formP [[1,2],[3]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i [] = xor True True"<br />
| "valorP i (x#xs) = xor (valorM i x) (valorP i xs)"<br />
<br />
value "valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]]"<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
by (induct p) (auto simp add:correccion_valorM)<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m [] = []"<br />
| "productoM m (x#xs) = [m@x] @ (productoM m xs)"<br />
<br />
value "productoM [1,3] [[1,2,4],[7],[4,1]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)" (is "?P i xs ys")<br />
proof (induct xs)<br />
show "?P i [] ys" by simp<br />
next<br />
fix a xs<br />
assume HI: "?P i xs ys"<br />
then show "?P i (a#xs) ys" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=537
Relación 12
2014-02-10T00:45:12Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
--"diecabmen1"<br />
lemma correccion_valorM2:<br />
"valorM i m = valorF i (formM m)" (is "?P i m")<br />
proof (induct m)<br />
show "?P i []" by simp<br />
next<br />
fix a m<br />
assume HI: "?P i m"<br />
then show "?P i (a#m)" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP [] = Xor T T"<br />
| "formP (x#xs) = Xor (formM x) (formP xs)"<br />
<br />
value "formP [[1,2],[3]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i [] = xor True True"<br />
| "valorP i (x#xs) = xor (valorM i x) (valorP i xs)"<br />
<br />
value "valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]]"<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
by (induct p) (auto simp add:correccion_valorM)<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m [] = []"<br />
| "productoM m (x#xs) = [m@x] @ (productoM m xs)"<br />
<br />
value "productoM [1,3] [[1,2,4],[7],[4,1]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=536
Relación 12
2014-02-10T00:31:24Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
--"diecabmen1"<br />
lemma correccion_valorM2:<br />
"valorM i m = valorF i (formM m)" (is "?P i m")<br />
proof (induct m)<br />
show "?P i []" by simp<br />
next<br />
fix a m<br />
assume HI: "?P i m"<br />
then show "?P i (a#m)" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP [] = Xor T T"<br />
| "formP (x#xs) = Xor (formM x) (formP xs)"<br />
<br />
value "formP [[1,2],[3]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i [] = xor True True"<br />
| "valorP i (x#xs) = xor (valorM i x) (valorP i xs)"<br />
<br />
value "valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]]"<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
by (induct p) (auto simp add:correccion_valorM)<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=535
Relación 12
2014-02-09T23:15:13Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
--"diecabmen1"<br />
lemma correccion_valorM2:<br />
"valorM i m = valorF i (formM m)" (is "?P i m")<br />
proof (induct m)<br />
show "?P i []" by simp<br />
next<br />
fix a m<br />
assume HI: "?P i m"<br />
then show "?P i (a#m)" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP [] = Xor T T"<br />
| "formP (x#xs) = Xor (formM x) (formP xs)"<br />
<br />
value "formP [[1,2],[3]]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=531
Relación 12
2014-02-09T15:45:52Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
--"diecabmen1"<br />
lemma correccion_valorM2:<br />
"valorM i m = valorF i (formM m)" (is "?P i m")<br />
proof (induct m)<br />
show "?P i []" by simp<br />
next<br />
fix a m<br />
assume HI: "?P i m"<br />
then show "?P i (a#m)" by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=530
Relación 12
2014-02-09T04:14:10Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by (induct m) auto<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=529
Relación 12
2014-02-09T04:13:20Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=528
Relación 12
2014-02-09T04:12:29Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i [] = True"<br />
| "valorM i (x#xs) = ((valorF i (Var x)) ∧ (valorM i xs))"<br />
<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by auto<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=527
Relación 12
2014-02-09T04:02:16Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i ns = valorF i (formM ns)"<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
by auto<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=526
Relación 12
2014-02-09T04:01:02Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i ns = valorF i (formM ns)"<br />
value "valorM int1 [0,2,1]"<br />
value "valorM (int1(0:=True,1:=True,2:=True)) [0,2,1]"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=525
Relación 12
2014-02-09T03:53:48Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun formM :: "nat list ⇒ form" where<br />
"formM [] = T"<br />
| "formM (x#xs) = And (Var x) (formM xs)"<br />
<br />
value "formM [0,2,1]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i ns = undefined"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=524
Relación 12
2014-02-09T03:48:06Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
--"diecabmen1"<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i T = True"<br />
| "valorF i (Var n) = i n"<br />
| "valorF i (And G H) = ((valorF i G) ∧ (valorF i H))"<br />
| "valorF i (Xor G H) = xor (valorF i G) (valorF i H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formM :: "nat list ⇒ form" where<br />
"formM ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i ns = undefined"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_12&diff=523
Relación 12
2014-02-09T02:58:09Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R12: Representación de fórmulas proposicionales mediante<br />
polinomios *}<br />
<br />
theory R12<br />
imports Main <br />
begin <br />
<br />
text {*<br />
El objetivo de esta relación es definir un procedimiento para<br />
transformar fórmulas proposicionales (construidas con ⊤, ∧ y ⊕) en<br />
polinomios de la forma<br />
(p₁ ∧ … ∧ pₙ) ⊕ … ⊕ (q₁ ∧ … ∧ qₘ)<br />
y demostrar que, para cualquier interpretación I, el valor de las<br />
fórmulas coincide con la de su correspondiente polinomio. *}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Las fórmulas proposicionales pueden definirse mediante<br />
las siguientes reglas:<br />
· ⊤ es una fórmula proposicional<br />
· Las variables proposicionales p_1, p_2, … son fórmulas<br />
proposicionales,<br />
· Si F y G son fórmulas proposicionales, entonces (F ∧ G) y (F ⊕ G)<br />
también lo son. <br />
donde ⊤ es una fórmula que siempre es verdadera, ∧ es la conjunción y<br />
⊕ es la disyunción exclusiva. <br />
<br />
Definir el tipo de datos form para representar las fórmulas<br />
proposicionales usando <br />
· T en lugar de ⊤,<br />
· (Var i) en lugar de p_i,<br />
· (And F G) en lugar de (F ∧ G) y<br />
· (Xor F G) en lugar de (F ⊕ G).<br />
------------------------------------------------------------------ *}<br />
<br />
datatype form = T | Var nat | And form form | Xor form form<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Los siguientes ejemplos de fórmulas<br />
form1 = p0 ⊕ ⊤<br />
form2 = (p0 ⊕ p1) ⊕ (p0 ∧ p1)<br />
es usará en lo que sigue.<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation form1 :: "form" where<br />
"form1 ≡ Xor (Var 0) T"<br />
abbreviation form2 :: "form" where<br />
"form2 ≡ Xor (Xor (Var 0) (Var 1)) (And (Var 0) (Var 1))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función<br />
xor :: bool ⇒ bool ⇒ bool<br />
tal que (xor p q) es el valor de la disyunción exclusiva de p y q. Por<br />
ejemplo,<br />
xor False True = True<br />
------------------------------------------------------------------ *}<br />
<br />
--"diecabmen1"<br />
definition xor :: "bool ⇒ bool ⇒ bool" where<br />
"xor x y ≡ (x∧¬y)∨(¬x∧y)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Una interpretación es una aplicación de los naturales en<br />
los booleanos. Definir las siguientes interpretaciones<br />
| p0 | p1 | p2 | p3 | ...<br />
int1 | F | F | F | F | ...<br />
int2 | F | V | F | F | ...<br />
int3 | V | F | F | F | ...<br />
int3 | V | V | F | F | ...<br />
------------------------------------------------------------------ *}<br />
<br />
abbreviation int1 :: "nat ⇒ bool" where<br />
"int1 x ≡ False"<br />
abbreviation int2 :: "nat ⇒ bool" where<br />
"int2 ≡ int1 (1 := True)"<br />
abbreviation int3 :: "nat ⇒ bool" where<br />
"int3 ≡ int1 (0 := True)"<br />
abbreviation int4 :: "nat ⇒ bool" where<br />
"int4 ≡ int1 (0 := True, 1 := True)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Dada una interpretación I, el valor de de una fórmula F<br />
repecto de I, I(F), se define por<br />
· T, si F es ⊤;<br />
· I(n), si F es p_n;<br />
· I(G) ∧ I(H), si F es (G ∧ H);<br />
· I(G) ⊕ I(H), si F es (G ⊕ H).<br />
<br />
Definir la función<br />
valorF :: (nat ⇒ bool) ⇒ form ⇒ bool<br />
tal que (valorF i f) es el valor de la fórmula f respecto de la<br />
interpretación i. Por ejemplo, <br />
valorF int1 form1 = True<br />
valorF int3 form1 = False<br />
valorF int1 form2 = False<br />
valorF int2 form2 = True<br />
valorF int3 form2 = True<br />
valorF int4 form2 = True<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorF :: "(nat ⇒ bool) ⇒ form ⇒ bool" where<br />
"valorF i f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un monomio es una lista de números naturales y se puede<br />
interpretar como la conjunción de variables proposionales cuyos<br />
índices son los números de la lista. Por ejemplo, el monomio [0,2,1]<br />
se interpreta como la fórmula (p0 ∧ p2 ∧ p1). <br />
<br />
Definir la función<br />
formM :: nat list ⇒ form<br />
tal que (formM m) es la fórmula correspondiente al monomio. Por<br />
ejemplo, <br />
formM [0,2,1] = And (Var 0) (And (Var 2) (And (Var 1) T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formM :: "nat list ⇒ form" where<br />
"formM ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Definir, por recursión, la función<br />
valorM :: (nat ⇒ bool) ⇒ nat list ⇒ bool<br />
tal que (valorM i m) es el valor de la fórmula representada por el<br />
monomio m en la interpretación i. Por ejemplo, <br />
valorM int1 [0,2,1] = False<br />
valorM (int1(0:=True,1:=True,2:=True)) [0,2,1] = True<br />
Demostrar que, para toda interpretación i y todo monomio m, se tiene<br />
que <br />
valorM i m = valorF i (formM m)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorM :: "(nat ⇒ bool) ⇒ nat list ⇒ bool" where<br />
"valorM i ns = undefined"<br />
<br />
lemma correccion_valorM:<br />
"valorM i m = valorF i (formM m)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Un polinomio es una lista de monomios y se puede<br />
interpretar como la disyunción exclusiva de los monomios. Por ejemplo, <br />
el polinomio [[0,2,1],[1,3]] se interpreta como la fórmula<br />
(p0 ∧ p2 ∧ p1) ⊕ (p1 ∧ p3).<br />
<br />
Definir la función<br />
formP :: nat list list ⇒ form<br />
tal que (formP p) es la fórmula correspondiente al polinomio p. Por<br />
ejemplo, <br />
formP [[1,2],[3]]<br />
= Xor (And (Var 1) (And (Var 2) T)) (Xor (And (Var 3) T) (Xor T T))<br />
--------------------------------------------------------------------- *}<br />
<br />
fun formP :: "nat list list ⇒ form" where<br />
"formP ms = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función<br />
valorP :: (nat ⇒ bool) ⇒ nat list list ⇒ bool<br />
tal que (valorP i p) es el valor de la fórmula representada por el<br />
polinomio p en la interpretación i. Por ejemplo, <br />
valorP (int1(1:=True,3:=True)) [[0,2,1],[1,3]] = True<br />
Demostrar que, para toda interpretación i y todo polinomio p, se tiene<br />
que <br />
valorM i p = valorF i (formP p)<br />
--------------------------------------------------------------------- *}<br />
<br />
fun valorP :: "(nat ⇒ bool) ⇒ nat list list ⇒ bool" where<br />
"valorP i ms = undefined"<br />
<br />
lemma correccion_valorP:<br />
"valorP i p = valorF i (formP p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función<br />
productoM :: nat list ⇒ nat list list ⇒ nat list list<br />
tal que (productoM m p) es el producto del monomio p por el polinomio<br />
p. Por ejemplo, <br />
productoM [1,3] [[1,2,4],[7],[4,1]] <br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun productoM :: "nat list ⇒ nat list list ⇒ nat list list" where<br />
"productoM m ns = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos monomios es la conjunción de sus valores.<br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorM_conc: <br />
"valorM i (xs @ ys) = (valorM i xs ∧ valorM i ys)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de un monomio por un polinomio es la conjunción de sus<br />
valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_productoM: <br />
"valorP i (productoM m p) = (valorM i m ∧ valorP i p)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Definir la función<br />
producto :: nat list list ⇒ nat list list ⇒ nat list list<br />
tal que (producto p q) es el producto de los polinomios p y q. Por <br />
ejemplo, <br />
producto [[1,3],[2]] [[1,2,4],[7],[4,1]]<br />
= [[1,3,1,2,4],[1,3,7],[1,3,4,1],[2,1,2,4],[2,7],[2,4,1]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun producto :: "nat list list ⇒ nat list list ⇒ nat list list" where<br />
"producto p q = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar que, en cualquier interpretación i, el valor <br />
de la concatenación de dos polinomios es la disyunción exclusiva de <br />
sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma valorP_conc: <br />
"valorP i (xs @ ys) = (xor (valorP i xs) (valorP i ys))"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar que, en cualquier interpretación i, el valor <br />
del producto de dos polinomios es la conjunción de sus valores. <br />
--------------------------------------------------------------------- *}<br />
<br />
lemma correccion_producto: <br />
"valorP i (producto p q) = (valorP i p ∧ valorP i q)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Definir la función<br />
polinomio :: form ⇒ nat list list<br />
tal que (polinomio f) es el polinomio que representa la fórmula f. Por <br />
ejemplo, <br />
polinomio (Xor (Var 1) (Var 2)) = [[1],[2]]<br />
polinomio (And (Var 1) (Var 2)) = [[1,2]]<br />
polinomio (Xor (Var 1) T) = [[1],[]]<br />
polinomio (And (Var 1) T) = [[1]]]<br />
polinomio (And (Xor (Var 1) (Var 2)) (Var 3)) = [[1,3],[2,3]]<br />
polinomio (Xor (And (Var 1) (Var 2)) (Var 3)) = [[1,2],[3]]<br />
--------------------------------------------------------------------- *}<br />
<br />
fun polinomio :: "form ⇒ nat list list" where<br />
"polinomio f = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar que, en cualquier interpretación i, el valor <br />
de f es igual que el de su polinomio. <br />
--------------------------------------------------------------------- *}<br />
<br />
theorem correccion_polinomio: <br />
"valorF i f = valorP i (polinomio f)"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=482
Relación 10
2014-01-25T17:04:44Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
proof<br />
assume "p"<br />
{ assume "¬q"<br />
with assms have "¬p" ..<br />
then have False using `p` ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_8:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
then have "p ∨ q" ..}<br />
{ assume "¬p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..}<br />
{ assume "¬q"<br />
with `¬p` have "¬p ∧ ¬q" ..<br />
with assms have False ..<br />
then have "p ∨ q" ..}<br />
with `¬q ∨ q` have "p ∨ q" using `q ⟹ p ∨ q` ..}<br />
with `¬p ∨ p` show "p ∨ q" using `p ⟹ p ∨ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_9:<br />
assumes "¬(¬p ∨ ¬q)"<br />
shows "p ∧ q"<br />
proof<br />
{ assume "¬p"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "p" by (rule ccontr)<br />
{ assume "¬q"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_10:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
with `p` have "p ∧ q" ..<br />
with assms have False ..<br />
then have "¬p ∨ ¬q" ..}<br />
{ assume "¬q"<br />
then have "¬p ∨ ¬q" ..}<br />
with `¬q ∨ q` have "¬p ∨ ¬q" using `q ⟹ ¬ p ∨ ¬ q` ..}<br />
{ assume "¬p"<br />
then have "¬p ∨ ¬q" ..}<br />
with `¬p ∨ p` show "¬p ∨ ¬q" using ` p ⟹ ¬ p ∨ ¬ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_11:<br />
shows "(p ⟶ q) ∨ (q ⟶ p)"<br />
proof -<br />
have "¬(p ⟶ q) ∨ (p ⟶ q)" ..<br />
{ assume "(p ⟶ q)"<br />
then have "(p ⟶ q) ∨ (q ⟶ p)" ..}<br />
{ assume "¬(p ⟶ q)"<br />
{ assume "q"<br />
{ assume "p"<br />
have "q" using `q` .}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` have False ..<br />
then have "p" ..}<br />
then have "q ⟶ p" ..<br />
then have "(p ⟶ q) ∨ (q ⟶ p)" ..}<br />
with `¬(p ⟶ q) ∨ (p ⟶ q)` show "(p ⟶ q) ∨ (q ⟶ p)" using `p ⟶ q ⟹ (p ⟶ q) ∨ (q ⟶ p)` ..<br />
qed<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=481
Relación 10
2014-01-25T16:46:06Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
proof<br />
assume "p"<br />
{ assume "¬q"<br />
with assms have "¬p" ..<br />
then have False using `p` ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_8:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
then have "p ∨ q" ..}<br />
{ assume "¬p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..}<br />
{ assume "¬q"<br />
with `¬p` have "¬p ∧ ¬q" ..<br />
with assms have False ..<br />
then have "p ∨ q" ..}<br />
with `¬q ∨ q` have "p ∨ q" using `q ⟹ p ∨ q` ..}<br />
with `¬p ∨ p` show "p ∨ q" using `p ⟹ p ∨ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_9:<br />
assumes "¬(¬p ∨ ¬q)"<br />
shows "p ∧ q"<br />
proof<br />
{ assume "¬p"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "p" by (rule ccontr)<br />
{ assume "¬q"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_10:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
with `p` have "p ∧ q" ..<br />
with assms have False ..<br />
then have "¬p ∨ ¬q" ..}<br />
{ assume "¬q"<br />
then have "¬p ∨ ¬q" ..}<br />
with `¬q ∨ q` have "¬p ∨ ¬q" using `q ⟹ ¬ p ∨ ¬ q` ..}<br />
{ assume "¬p"<br />
then have "¬p ∨ ¬q" ..}<br />
with `¬p ∨ p` show "¬p ∨ ¬q" using ` p ⟹ ¬ p ∨ ¬ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=480
Relación 10
2014-01-25T16:28:33Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
proof<br />
assume "p"<br />
{ assume "¬q"<br />
with assms have "¬p" ..<br />
then have False using `p` ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_8:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
then have "p ∨ q" ..}<br />
{ assume "¬p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..}<br />
{ assume "¬q"<br />
with `¬p` have "¬p ∧ ¬q" ..<br />
with assms have False ..<br />
then have "p ∨ q" ..}<br />
with `¬q ∨ q` have "p ∨ q" using `q ⟹ p ∨ q` ..}<br />
with `¬p ∨ p` show "p ∨ q" using `p ⟹ p ∨ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_9:<br />
assumes "¬(¬p ∨ ¬q)"<br />
shows "p ∧ q"<br />
proof<br />
{ assume "¬p"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "p" by (rule ccontr)<br />
{ assume "¬q"<br />
then have "¬p ∨ ¬q" ..<br />
with assms have False ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=479
Relación 10
2014-01-25T15:42:48Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
proof<br />
assume "p"<br />
{ assume "¬q"<br />
with assms have "¬p" ..<br />
then have False using `p` ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_8:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
proof -<br />
have "¬p ∨ p" ..<br />
{ assume "p"<br />
then have "p ∨ q" ..}<br />
{ assume "¬p"<br />
have "¬q ∨ q" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..}<br />
{ assume "¬q"<br />
with `¬p` have "¬p ∧ ¬q" ..<br />
with assms have False ..<br />
then have "p ∨ q" ..}<br />
with `¬q ∨ q` have "p ∨ q" using `q ⟹ p ∨ q` ..}<br />
with `¬p ∨ p` show "p ∨ q" using `p ⟹ p ∨ q` ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=478
Relación 10
2014-01-25T15:02:10Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
proof<br />
assume "p"<br />
{ assume "¬q"<br />
with assms have "¬p" ..<br />
then have False using `p` ..}<br />
then show "q" by (rule ccontr)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=477
Relación 10
2014-01-25T02:54:23Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
shows "((p ⟶ q) ⟶ p) ⟶ p"<br />
proof<br />
assume "(p ⟶ q) ⟶ p"<br />
show "p"<br />
proof (rule ccontr)<br />
assume "¬p"<br />
with `(p ⟶ q) ⟶ p` have "¬(p ⟶ q)" by (rule mt)<br />
{ assume "p"<br />
with `¬p` have False ..<br />
then have "q" ..}<br />
then have "p ⟶ q" ..<br />
with `¬(p ⟶ q)` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=476
Relación 10
2014-01-25T02:30:43Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4 diecabmen1"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=475
Relación 10
2014-01-25T02:08:22Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_4:<br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using assms ..<br />
then show False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using assms ..<br />
then show False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=474
Relación 10
2014-01-25T01:59:58Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1 maresccas4"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬p" ..<br />
next<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with `¬(p ∨ q)` have False ..}<br />
thus "¬q" ..<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
assumes "¬(p ∨ q)"<br />
shows "¬p ∧ ¬q"<br />
proof -<br />
{ assume "p"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬p" ..<br />
{ assume "q"<br />
then have "p ∨ q" ..<br />
with assms have False ..}<br />
then have "¬q" ..<br />
with `¬p` show "¬p ∧ ¬q" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma <br />
assumes "¬p ∧ ¬q"<br />
shows "¬(p ∨ q)"<br />
proof<br />
assume "p ∨ q"<br />
show False<br />
using `p ∨ q`<br />
proof<br />
assume "p"<br />
have "¬p" using `¬p ∧ ¬q` ..<br />
thus False using `p` ..<br />
next<br />
assume "q"<br />
have "¬q" using `¬p ∧ ¬q` ..<br />
thus False using `q` ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "maresccas4"<br />
lemma<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
proof<br />
assume "p ∧ q"<br />
show False<br />
using `¬p ∨ ¬q`<br />
proof<br />
assume "¬p"<br />
have "p" using `p ∧ q` ..<br />
with `¬p`show False ..<br />
next<br />
assume "¬q"<br />
have "q" using `p ∧ q` ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=472
Relación 10
2014-01-25T00:57:18Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
--"diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof <br />
assume 1: "¬p ∨ ¬q"<br />
show False<br />
using 1<br />
proof (rule disjE)<br />
assume "¬p"<br />
have "p" using assms ..<br />
with `¬p` show False ..<br />
next<br />
assume "¬q"<br />
have "q" using assms ..<br />
with `¬q` show False ..<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_10&diff=471
Relación 10
2014-01-25T00:34:49Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R10: Deducción natural proposicional *}<br />
<br />
theory R10<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Los ejercicios son los de la asignatura de "Lógica informática" que se<br />
encuentran en http://goo.gl/yrPLn<br />
<br />
Las reglas básicas de la deducción natural son las siguientes:<br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬ P ⟹ P<br />
· notnotI: P ⟹ ¬¬ P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
· FalseE: False ⟹ P<br />
· notE: ⟦¬P; P⟧ ⟹ R<br />
· notI: (P ⟹ False) ⟹ ¬P<br />
· iffI: ⟦P ⟹ Q; Q ⟹ P⟧ ⟹ P = Q<br />
· iffD1: ⟦Q = P; Q⟧ ⟹ P <br />
· iffD2: ⟦P = Q; Q⟧ ⟹ P<br />
· ccontr: (¬P ⟹ False) ⟹ P<br />
· excluded_middle: ¬P ∨ P<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ∨ q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 01:<br />
assumes 1: "p ∨ q"<br />
and 2: "¬q"<br />
shows "p"<br />
using 1<br />
proof (rule disjE)<br />
{assume "p" <br />
then show "p".}<br />
next<br />
{assume "q"<br />
with 2 show "p" by (rule notE)}<br />
qed<br />
<br />
--"diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ∨ q"<br />
"¬q"<br />
shows "p"<br />
using assms(1)<br />
proof (rule disjE)<br />
assume "p"<br />
then show "p" .<br />
next<br />
assume "q"<br />
with `¬q` show "p" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
--"marescpla, pabflomar"<br />
<br />
lemma 02:<br />
assumes "p ∧ q"<br />
shows "¬(¬p ∨ ¬q)"<br />
proof (rule ccontr)<br />
assume "¬¬(¬p ∨ ¬q)"<br />
then have 1: "(¬p ∨ ¬q)" by (rule notnotD)<br />
show "False"<br />
using 1<br />
proof (rule disjE)<br />
{assume I: "¬p"<br />
have "p" using assms(1) by (rule conjunct1)<br />
with I show "False"..}<br />
{assume II: "¬q"<br />
have "q" using assms(1) by (rule conjunct2)<br />
with II show "False" ..}<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=435
Relación 9
2014-01-20T14:30:50Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof<br />
assume "p ⟶ q ⟶ r"<br />
show "(p ⟶ q) ⟶ p ⟶ r"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_5:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof<br />
assume "p"<br />
have "(p ⟶ q)" using assms ..<br />
then have "q" using `p` ..<br />
have "(p ⟶ r)" using assms ..<br />
then have "r" using `p` ..<br />
with `q` show "q ∧ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "q" ..}<br />
then show "p ⟶ q" ..<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "r" ..}<br />
then show "p ⟶ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof<br />
assume "p ⟶ q"<br />
have "p" using assms ..<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms ..<br />
then show "r" using `q` ..<br />
qed<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei diecabmen1"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei diecabmen1"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei diecabmen1"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=434
Relación 9
2014-01-20T02:33:43Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof<br />
assume "p ⟶ q ⟶ r"<br />
show "(p ⟶ q) ⟶ p ⟶ r"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_5:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof<br />
assume "p"<br />
have "(p ⟶ q)" using assms ..<br />
then have "q" using `p` ..<br />
have "(p ⟶ r)" using assms ..<br />
then have "r" using `p` ..<br />
with `q` show "q ∧ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "q" ..}<br />
then show "p ⟶ q" ..<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "r" ..}<br />
then show "p ⟶ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_7:<br />
assumes "p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof<br />
assume "p ⟶ q"<br />
have "p" using assms ..<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms ..<br />
then show "r" using `q` ..<br />
qed<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=433
Relación 9
2014-01-20T02:04:39Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof<br />
assume "p ⟶ q ⟶ r"<br />
show "(p ⟶ q) ⟶ p ⟶ r"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_5:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof<br />
assume "p"<br />
have "(p ⟶ q)" using assms ..<br />
then have "q" using `p` ..<br />
have "(p ⟶ r)" using assms ..<br />
then have "r" using `p` ..<br />
with `q` show "q ∧ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_6:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "q" ..}<br />
then show "p ⟶ q" ..<br />
{assume "p"<br />
with assms have "q ∧ r" ..<br />
then have "r" ..}<br />
then show "p ⟶ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=432
Relación 9
2014-01-20T00:43:14Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof<br />
assume "p ⟶ q ⟶ r"<br />
show "(p ⟶ q) ⟶ p ⟶ r"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_5:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof<br />
assume "p"<br />
have "(p ⟶ q)" using assms ..<br />
then have "q" using `p` ..<br />
have "(p ⟶ r)" using assms ..<br />
then have "r" using `p` ..<br />
with `q` show "q ∧ r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=431
Relación 9
2014-01-19T22:53:02Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_3:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof<br />
assume "p ⟶ q ⟶ r"<br />
show "(p ⟶ q) ⟶ p ⟶ r"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using `p ⟶ q ⟶ r` `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=430
Relación 9
2014-01-19T22:33:42Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_2:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof <br />
assume "p ⟶ q"<br />
show "p ⟶ r"<br />
proof<br />
assume "p"<br />
with `p ⟶ q` have "q" ..<br />
have "q ⟶ r" using assms `p` ..<br />
then show "r" using `q` ..<br />
qed<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_9&diff=429
Relación 9
2014-01-19T19:32:05Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R9: Deducción natural proposicional (1) *}<br />
<br />
theory R9<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es lemas usando sólo las reglas básicas<br />
de deducción natural de la lógica proposicional. <br />
<br />
Las reglas básicas de la deducción natural necesarias son las<br />
siguientes: <br />
· conjI: ⟦P; Q⟧ ⟹ P ∧ Q<br />
· conjunct1: P ∧ Q ⟹ P<br />
· conjunct2: P ∧ Q ⟹ Q <br />
· notnotD: ¬¬P ⟹ P<br />
· notnotI: P ⟹ ¬¬P<br />
· mp: ⟦P ⟶ Q; P⟧ ⟹ Q <br />
· mt: ⟦F ⟶ G; ¬G⟧ ⟹ ¬F <br />
· impI: (P ⟹ Q) ⟹ P ⟶ Q<br />
· disjI1: P ⟹ P ∨ Q<br />
· disjI2: Q ⟹ P ∨ Q<br />
· disjE: ⟦P ∨ Q; P ⟹ R; Q ⟹ R⟧ ⟹ R <br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación.<br />
*}<br />
<br />
lemma notnotI: "P ⟹ ¬¬ P"<br />
by auto<br />
<br />
lemma mt: "⟦F ⟶ G; ¬G⟧ ⟹ ¬F"<br />
by auto<br />
<br />
section {* Implicaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 1. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej1_auto:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
using assms<br />
by auto<br />
<br />
lemma ej1:<br />
assumes 1:"p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 2:"q"<br />
{assume 3:"p"<br />
have 4:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 4 2 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "q⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
-- "diecabmen1"<br />
lemma Ejercicio_1:<br />
assumes "p ⟶ (q ⟶ r)"<br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{ assume "q"<br />
{ assume "p"<br />
with assms have "q ⟶ r" ..<br />
then have "r" using `q` .. }<br />
then have "p ⟶ r" .. }<br />
then show "q ⟶ (p ⟶ r)" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej2_auto:<br />
assumes " p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej2:<br />
assumes 1:" p ⟶ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
proof - <br />
{assume 2:"(p ⟶ q)"<br />
{assume 3:"p"<br />
have 4:"q" using 2 3 by (rule mp)<br />
have 5:"q⟶r" using 1 3 by (rule mp)<br />
have "r" using 5 4 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then show "(p ⟶ q)⟶(p⟶r)" by (rule impI)<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej3_auto:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
by auto<br />
<br />
lemma ej3:"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
proof - <br />
{ assume 1:"(p⟶(q⟶r))"<br />
{assume 3:"p⟶q"<br />
{assume 4:"p"<br />
have 5: "q⟶r" using 1 4 by (rule mp)<br />
have 6:"q" using 3 4 by (rule mp)<br />
have "r" using 5 6 by (rule mp)}<br />
then have "p⟶r" by (rule impI)}<br />
then have "(p⟶q)⟶p⟶r" by (rule impI)}<br />
then show "(p⟶(q⟶r))⟶((p⟶q)⟶p⟶r)" by (rule impI) <br />
qed<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej4_auto:<br />
assumes "(p ⟶ q) ⟶ r"<br />
shows "p ⟶ (q ⟶ r)"<br />
using assms by auto<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej5_auto:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
using assms by auto<br />
<br />
lemma ej5:<br />
assumes 1:"(p ⟶ q) ∧ (p ⟶ r)"<br />
shows "p ⟶ q ∧ r"<br />
proof -<br />
{assume 2:"p"<br />
have 3: "p⟶q" using 1 by (rule conjunct1)<br />
have 4: "p⟶r" using 1 by (rule conjunct2)<br />
have 5: "q" using 3 2 by (rule mp)<br />
have 6: "r" using 4 2 by (rule mp)<br />
have "q ∧ r" using 5 6 by (rule conjI)}<br />
then show "p ⟶ q ∧ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej6_auto:<br />
assumes "p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej6:<br />
assumes 1:"p ⟶ q ∧ r"<br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"q∧r" using 1 2 by (rule mp)<br />
have "q" using 3 by (rule conjunct1)}<br />
then have 4:"p⟶q" by (rule impI)<br />
{assume 5:"p"<br />
have 6:"q∧r" using 1 5 by (rule mp)<br />
have "r" using 6 by (rule conjunct2)}<br />
then have 5:"p⟶r" by (rule impI)<br />
show "(p⟶q) ∧ (p ⟶r)" using 4 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej7_auto:<br />
assumes " p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej7:<br />
assumes 1:" p ∧ (q ⟶ r)"<br />
shows "(p ⟶ q) ⟶ r"<br />
proof -<br />
have 2:"p" using 1 by (rule conjunct1)<br />
have 3:"q⟶r" using 1 by (rule conjunct2)<br />
{assume 4:"p⟶q"<br />
have 5:"q" using 4 2 by (rule mp)<br />
have "r" using 3 5 by (rule mp)}<br />
then show "(p⟶q)⟶r" by (rule impI)<br />
qed<br />
<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej8_auto:<br />
assumes "q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
using assms by auto<br />
<br />
lemma ej8:<br />
assumes 1:"q ⟶ r"<br />
shows "p ∨ q ⟶ p ∨ r"<br />
proof -<br />
{assume 2:"p ∨ q"<br />
moreover<br />
{assume "p"<br />
then have "p ∨ r" by (rule disjI1)}<br />
moreover<br />
{assume 3:"q"<br />
have "r" using 1 3 by (rule mp)<br />
then have "p ∨ r" by (rule disjI2)}<br />
ultimately have "p ∨ r" by (rule disjE)}<br />
then show "p ∨ q ⟶ p ∨ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej9_auto:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
using assms by auto<br />
<br />
lemma ej9:<br />
assumes 1:"(p ⟶ r) ∧ (q ⟶ r)"<br />
shows "p ∨ q ⟶ r"<br />
proof -<br />
{assume "p ∨ q "<br />
moreover <br />
{assume 2:"p"<br />
have 3:"(p ⟶ r)" using 1 by (rule conjunct1) <br />
have "r" using 3 2 by (rule mp)}<br />
moreover<br />
{assume 4:"q"<br />
have 5:"(q ⟶ r)" using 1 by (rule conjunct2)<br />
have "r" using 5 4 by (rule mp)}<br />
ultimately have "r" ..}<br />
then show "p ∨ q ⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "irealetei"<br />
lemma ej10_auto:<br />
assumes "p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
using assms by auto<br />
<br />
lemma ej10:<br />
assumes 1:"p ∨ q ⟶ r"<br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
proof -<br />
{assume 2:"p"<br />
have 3:"p∨q" using 2 by (rule disjI1)<br />
have "r" using 1 3 by (rule mp)}<br />
then have 4:"p⟶r" by (rule impI)<br />
{assume 5:"q"<br />
have 6:"p∨q" using 5 by (rule disjI2)<br />
have 7:"r" using 1 6 by (rule mp)}<br />
then have 8:"q⟶r" by (rule impI)<br />
show "(p⟶r)∧(q⟶r)" using 4 8 by (rule conjI)<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_8&diff=408
Relación 8
2014-01-16T01:45:10Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R8: Árboles binarios completos *}<br />
<br />
theory R8_Arboles_binarios_completos<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que no tienen información ni en los nodos y ni en las<br />
hojas. Por ejemplo, el árbol<br />
·<br />
/ \<br />
/ \<br />
· ·<br />
/ \ / \<br />
· · · · <br />
se representa por "N (N H H) (N H H)".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype arbol = H | N arbol arbol<br />
<br />
value "N (N H H) (N H H)"<br />
value "(N (N H H) (N (N H H) H))" --"Este tambien es un arbol segun la definicion del tipo. Sin embargo no es completo."<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función<br />
hojas :: "arbol => nat" <br />
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,<br />
hojas (N (N H H) (N H H)) = 4<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1 irealetei juaruipav"<br />
fun hojas :: "arbol => nat" where<br />
"hojas H = Suc 0"<br />
| "hojas (N i d) = hojas i + hojas d"<br />
<br />
--"julrobrel maresccas4"<br />
fun hojas_jrr :: "arbol => nat" where<br />
"hojas_jrr H = 1" --"julrobrel: minima diferencia con la anterior"<br />
|"hojas_jrr (N i d) = (hojas_jrr i) + (hojas_jrr d)"<br />
<br />
value "hojas_jrr (N (N H H) (N H H))" -- "= 4"<br />
<br />
value "hojas (N (N H H) (N H H))" -- "= 4"<br />
value "hojas (N (N H H) (N (N H H) H))" --"= 5" --"julrobrel: la funcion tambien funciona sobre arboles binarios no completos"<br />
<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función<br />
profundidad :: "arbol => nat" <br />
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,<br />
profundidad (N (N H H) (N H H)) = 2<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1 juaruipav"<br />
fun profundidad :: "arbol => nat" where<br />
"profundidad H = 0"<br />
| "profundidad (N i d) = (if profundidad i > profundidad d then Suc (profundidad i) else Suc (profundidad d))"<br />
<br />
--"julrobrel"<br />
fun maximo :: "nat => nat => nat" where<br />
"maximo a b = (if a < b then b else a)"<br />
<br />
value "maximo 3 4" -- "=4"<br />
<br />
--"julrobrel"<br />
fun profundidad_jrr :: "arbol => nat" where<br />
"profundidad_jrr H = 0"<br />
|"profundidad_jrr (N i d) = Suc (maximo (profundidad_jrr i) (profundidad_jrr d))" --"julrobrel: En realidad al ser arboles completos no deberia hacer falta el maximo"<br />
<br />
value "profundidad (N (N H H) (N H H))" -- "= 2"<br />
value "profundidad (N (N H H) (N (N H H) H))" -- "= 3" --"julrobrel: profundidad tambien funciona sobre arboles binarios no completos"<br />
<br />
value "profundidad_jrr (N (N H H) (N H H))" -- "= 2"<br />
value "profundidad_jrr (N (N H H) (N (N H H) H))" -- "= 3" --"julrobrel: profundidad tambien funciona sobre arboles binarios no completos"<br />
<br />
<br />
--"irealetei maresccas4"<br />
fun profundidad3 :: "arbol => nat" where<br />
"profundidad3 (H) = 0"<br />
| "profundidad3 (N ai ad) = 1 + (if (profundidad3 ai > profundidad3 ad) then profundidad3 ai else profundidad3 ad)"<br />
<br />
value "profundidad3 (N (N H H) (N H (N H (N H H))))" -- "= 4"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función<br />
abc :: "nat ⇒ arbol" <br />
tal que (abc n) es el árbol binario completo de profundidad n. Por<br />
ejemplo, <br />
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1, julrobrel irealetei juaruipav maresccas4"<br />
fun abc :: "nat ⇒ arbol" where<br />
"abc 0 = H"<br />
| "abc (Suc n) = (N (abc n) (abc n))"<br />
<br />
value "abc 3" -- "= N (N (N H H) (N H H)) (N (N H H) (N H H))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si<br />
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i<br />
como d son árboles binarios completos respecto de f y, además, <br />
f(i) = f(r).<br />
<br />
Definir la función<br />
es_abc :: "(arbol => 'a) => arbol => bool<br />
tal que (es_abc f a) se verifica si a es un árbol binario completo<br />
respecto de f.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1 irealetei juaruipav maresccas4"<br />
fun es_abc :: "(arbol => 'a) => arbol => bool" where<br />
"es_abc f H = True"<br />
| "es_abc f (N i d) = ((es_abc f i) ∧ (es_abc f d) ∧ (f i = f d))"<br />
<br />
value "es_abc profundidad ( N (N (N H H) (N H H)) (N (N H H) (N H H)))" -- "true"<br />
value "es_abc profundidad ( N (N (N H H) (N H H)) (N H (N H H)))" -- "false"<br />
value "es_abc profundidad ( N (N (N H H) (N H H)) (N (N H H) H))" -- "false"<br />
value "es_abc profundidad ( N (N H (N H H)) (N H (N H H)))" -- "false"<br />
<br />
--"julrobrel"<br />
fun es_abc_jrr:: "nat => arbol => bool" where<br />
"es_abc_jrr 0 H = True"<br />
|"es_abc_jrr (Suc f) H = False"<br />
|"es_abc_jrr 0 (N i d) = False" <br />
|"es_abc_jrr (Suc f) (N i d) = (((es_abc_jrr f i) ∧ (es_abc_jrr f d)) ∧ ((profundidad_jrr i) = (profundidad_jrr d)) ∧ ((profundidad_jrr i) = f))"<br />
<br />
value "es_abc_jrr 2 (N (N H H) (N H H))"<br />
value "es_abc_jrr 0 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"<br />
value "es_abc_jrr 1 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"<br />
value "es_abc_jrr 2 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"<br />
value "es_abc_jrr 3 (N (N H H) (N (N H H) H))" --"=False" --"julrobrel: No es un arbol binario completo"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,<br />
size (N (N H H) (N H H)) = 3<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
value "size (N (N H H) (N H H))"<br />
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"<br />
value "size (N (N H H) (N (N H H) H))" --"julrobrel: No es un arbol binario completo"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. Tenemos 3 funciones de medida sobre los árboles: número de<br />
hojas, número de nodos y profundidad. A cada una le corresponde un<br />
concepto de completitud. En los siguientes ejercicios demostraremos<br />
que los tres conceptos de completitud son iguales.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de hojas.<br />
--------------------------------------------------------------------- <br />
*}<br />
--"julrobrel: en un arbol binario completo la profundidad y las hojas estan relacionadas por la siguiente igualdad (hojas = 2^profundidad)"<br />
lemma "(hojas (abc n))=2^(profundidad (abc n))"<br />
by (induct n) auto<br />
<br />
--"irealetei: casi me estalla el cerebro con esta demo, gracias a Marco que me dio una pista hace un par de días sobre que el había usado el assumes. La automática se me queda a medias., diecabmen1"<br />
lemma 00:<br />
assumes "es_abc profundidad a"<br />
shows "hojas a = 2^(profundidad a)"<br />
using assms<br />
by (induct a) auto<br />
<br />
lemma "es_abc hojas a = es_abc profundidad a"<br />
by (induct a) (auto simp add: 00)<br />
<br />
-- "maresccas4: no he sido capaz de terminar la demostración manual"<br />
theorem "es_abc profundidad a = es_abc hojas a" (is "?P a")<br />
proof (induct a)<br />
show "?P H" by simp<br />
next<br />
fix i d<br />
assume H1: "?P i"<br />
assume H2: "?P d"<br />
show "?P (N i d)"<br />
proof (cases)<br />
assume H: "es_abc profundidad (N i d)"<br />
then have "es_abc profundidad (N i d) = (es_abc profundidad i ∧ es_abc profundidad d ∧ profundidad i = profundidad d)" by simp<br />
also have "... = (es_abc hojas i ∧ es_abc hojas d ∧ profundidad i = profundidad d)" using H1 H2 by simp<br />
also have "... = (es_abc hojas i ∧ es_abc hojas d ∧ hojas i = hojas d)" using H by (simp add: 00)<br />
also have "... = es_abc hojas (N i d)" by simp<br />
finally show ?thesis .<br />
next<br />
assume H: "¬ es_abc profundidad (N i d)"<br />
show "?P (N i d)"<br />
proof (cases)<br />
assume I: "(es_abc profundidad i ∧ es_abc profundidad d)"<br />
then have "es_abc profundidad (N i d) = (es_abc profundidad i ∧ es_abc profundidad d ∧ profundidad i = profundidad d)" by simp<br />
also have "...= (profundidad i = profundidad d)" using H I by simp<br />
<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del<br />
número de hojas syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
--"julrobrel: la relacion entre hojas y nodos la da la siguiente ecuacion (nodos = hojas -1) o lo que es lo mismo (nodos+1=hojas)"<br />
lemma "Suc(size (abc n))=hojas (abc n)"<br />
by (induct n) auto<br />
<br />
-- "irealetei maresccas4 diecabmen1"<br />
(*he conseguido hacer uno!! bieeeeeeeen!!"*)<br />
lemma relaccion_hojas_nodo:"hojas (a) = size (a) + 1"<br />
by (induct a) auto<br />
<br />
<br />
lemma "es_abc hojas a = es_abc size a"<br />
by (induct a) (auto simp add: relaccion_hojas_nodo)<br />
<br />
lemma "es_abc hojas a = es_abc size a"<br />
proof (induct a)<br />
show "es_abc hojas H = es_abc size H" by simp<br />
next <br />
fix i d<br />
assume HI1:"es_abc hojas i = es_abc size i"<br />
assume HI2:"es_abc hojas d = es_abc size d"<br />
show " es_abc hojas (N i d) = es_abc size (N i d)"<br />
proof -<br />
have "es_abc hojas (N i d) = (es_abc hojas i ∧ es_abc hojas d ∧ hojas i = hojas d)" by simp<br />
also have "... = (es_abc size i ∧ es_abc size d ∧ hojas i = hojas d)" using HI1 HI2 by simp<br />
also have "... = (es_abc size i ∧ es_abc size d ∧ size i = size d)" by (simp add:relaccion_hojas_nodo)<br />
also have "... = es_abc size (N i d)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
--"julrobrel: la relacion entre la profundidad y el numero de nodos es (nodos+1=2^profundidad)"<br />
lemma "Suc(size (abc n))=2^(profundidad (abc n))"<br />
by (induct n) auto<br />
<br />
-- "irealetei: suponía que sería como el 7 pero no sale... por mucho que me pongo a definir lemas. De todos modos dejo donde me he quedado"<br />
lemma 02:<br />
assumes "es_abc size a"<br />
shows "size a + 1 = 2^(profundidad a)"<br />
using assms<br />
by (induct a) auto<br />
<br />
lemma 03:<br />
assumes "es_abc hojas a"<br />
shows "Suc(size a) = hojas a"<br />
using assms<br />
by (induct a) auto<br />
<br />
<br />
lemma "es_abc profundidad a = es_abc size a"<br />
by (induct a) (auto simp add:00 02 03) --"He puesto todas la teorías aunque suponía que con 02 sería suficiente"<br />
<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.<br />
--------------------------------------------------------------------- <br />
*}<br />
--"julrobrel: para todo lo anterior nos hemos basado en que (abc n) siempre devuelve un arbol binario completo. Habra que demostrarlo..."<br />
lemma profundidad_lemma: "profundidad_jrr (abc n) = n"<br />
by (induct n) auto<br />
<br />
lemma "es_abc_jrr n (abc n)"<br />
by (induct n) (auto simp add:profundidad_lemma)<br />
<br />
-- "irealetei"<br />
lemma "es_abc profundidad (abc n)" by (induct n) auto<br />
(* irealetei: es raro, hay que hacerlo por induct aunque parece que no usa la HI... pero por cases no se lo traga*)<br />
lemma "es_abc profundidad (abc n)"<br />
proof (induct n)<br />
show "es_abc profundidad (abc 0)" by simp<br />
next<br />
fix n<br />
assume " es_abc profundidad (abc n)"<br />
then have "es_abc profundidad (abc (Suc n))= es_abc profundidad (N (abc n) (abc n))" by simp<br />
also have "... = es_abc profundidad (abc n)" by simp<br />
finally show "es_abc profundidad (abc n) ⟹ es_abc profundidad (abc (Suc n))" by simp<br />
qed<br />
<br />
-- "maresccas4"<br />
lemma "es_abc profundidad (abc n)"<br />
proof (induct n)<br />
show "es_abc profundidad (abc 0)" by simp<br />
next<br />
fix n<br />
assume HI: "es_abc profundidad (abc n)"<br />
then have "es_abc profundidad (abc (Suc n))= es_abc profundidad (N (abc n) (abc n))" by simp<br />
also have "...= (es_abc profundidad (abc n) ∧ es_abc profundidad (abc n) ∧ profundidad (abc n) = profundidad (abc n))" by simp<br />
finally show "es_abc profundidad (abc (Suc n))" using HI by simp<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que si a es un árbolo binario completo<br />
respecto de la profundidad, entonces a es (abc (profundidad a)).<br />
--------------------------------------------------------------------- <br />
*}<br />
lemma "(es_abc_jrr (profundidad_jrr a) a) ⟶ a = abc (profundidad_jrr a)"<br />
by (induct a) auto<br />
<br />
--"irealetei maresccas4"<br />
lemma "es_abc profundidad a ⟹ a = abc (profundidad a)" by (induct a) auto<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de <br />
(es_abc size).<br />
--------------------------------------------------------------------- <br />
*}<br />
--"julrobrel"<br />
lemma "es_abc_jrr f t = es_abc_jrr (size t) t"<br />
quickcheck<br />
oops<br />
--"julrobrel: El arbol que es una hoja..."<br />
(*<br />
Quickcheck found a counterexample:<br />
<br />
f = Suc 0<br />
t = H<br />
<br />
Evaluated terms:<br />
es_abc f t = False<br />
es_abc (size t) t = True<br />
*)<br />
<br />
-- "irealetei maresccas4"<br />
lemma "es_abc f a = es_abc size a"<br />
quickcheck<br />
oops<br />
<br />
(*f = λx. a<br />
a = N H (N H H)*)<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_8&diff=398
Relación 8
2014-01-11T01:06:11Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R8: Árboles binarios completos *}<br />
<br />
theory R8_Arboles_binarios_completos<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que no tienen información ni en los nodos y ni en las<br />
hojas. Por ejemplo, el árbol<br />
·<br />
/ \<br />
/ \<br />
· ·<br />
/ \ / \<br />
· · · · <br />
se representa por "N (N H H) (N H H)".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype arbol = H | N arbol arbol<br />
<br />
value "N (N H H) (N H H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función<br />
hojas :: "arbol => nat" <br />
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,<br />
hojas (N (N H H) (N H H)) = 4<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun hojas :: "arbol => nat" where<br />
"hojas H = Suc 0"<br />
| "hojas (N i d) = hojas i + hojas d"<br />
<br />
value "hojas (N (N H H) (N H H))" -- "= 4"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función<br />
profundidad :: "arbol => nat" <br />
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,<br />
profundidad (N (N H H) (N H H)) = 2<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun profundidad :: "arbol => nat" where<br />
"profundidad H = 0"<br />
| "profundidad (N i d) = (if profundidad i > profundidad d then Suc (profundidad i) else Suc (profundidad d))"<br />
<br />
value "profundidad (N (N H H) (N H H))" -- "= 2"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función<br />
abc :: "nat ⇒ arbol" <br />
tal que (abc n) es el árbol binario completo de profundidad n. Por<br />
ejemplo, <br />
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun abc :: "nat ⇒ arbol" where<br />
"abc 0 = H"<br />
| "abc (Suc n) = (N (abc n) (abc n))"<br />
<br />
value "abc 3" -- "= N (N (N H H) (N H H)) (N (N H H) (N H H))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si<br />
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i<br />
como d son árboles binarios completos respecto de f y, además, <br />
f(i) = f(r).<br />
<br />
Definir la función<br />
es_abc :: "(arbol => 'a) => arbol => bool<br />
tal que (es_abc f a) se verifica si a es un árbol binario completo<br />
respecto de f.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun es_abc :: "(arbol => 'a) => arbol => bool" where<br />
"es_abc f H = True"<br />
| "es_abc f (N i d) = ((es_abc f i) ∧ (es_abc f d) ∧ (f i = f d))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,<br />
size (N (N H H) (N H H)) = 3<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
value "size (N (N H H) (N H H))"<br />
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. Tenemos 3 funciones de medida sobre los árboles: número de<br />
hojas, número de nodos y profundidad. A cada una le corresponde un<br />
concepto de completitud. En los siguientes ejercicios demostraremos<br />
que los tres conceptos de completitud son iguales.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de hojas.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del<br />
número de hojas syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que si a es un árbolo binario completo<br />
respecto de la profundidad, entonces a es (abc (profundidad a)).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de <br />
(es_abc size).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_8&diff=397
Relación 8
2014-01-10T01:54:42Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R8: Árboles binarios completos *}<br />
<br />
theory R8_Arboles_binarios_completos<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que no tienen información ni en los nodos y ni en las<br />
hojas. Por ejemplo, el árbol<br />
·<br />
/ \<br />
/ \<br />
· ·<br />
/ \ / \<br />
· · · · <br />
se representa por "N (N H H) (N H H)".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype arbol = H | N arbol arbol<br />
<br />
value "N (N H H) (N H H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función<br />
hojas :: "arbol => nat" <br />
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,<br />
hojas (N (N H H) (N H H)) = 4<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun hojas :: "arbol => nat" where<br />
"hojas H = Suc 0"<br />
| "hojas (N i d) = hojas i + hojas d"<br />
<br />
value "hojas (N (N H H) (N H H))" -- "= 4"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función<br />
profundidad :: "arbol => nat" <br />
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,<br />
profundidad (N (N H H) (N H H)) = 2<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun profundidad :: "arbol => nat" where<br />
"profundidad H = 0"<br />
| "profundidad (N i d) = (if profundidad i > profundidad d then Suc (profundidad i) else Suc (profundidad d))"<br />
<br />
value "profundidad (N (N H H) (N H H))" -- "= 2"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función<br />
abc :: "nat ⇒ arbol" <br />
tal que (abc n) es el árbol binario completo de profundidad n. Por<br />
ejemplo, <br />
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun abc :: "nat ⇒ arbol" where<br />
"abc 0 = H"<br />
| "abc (Suc n) = (N (abc n) (abc n))"<br />
<br />
value "abc 3" -- "= N (N (N H H) (N H H)) (N (N H H) (N H H))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si<br />
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i<br />
como d son árboles binarios completos respecto de f y, además, <br />
f(i) = f(r).<br />
<br />
Definir la función<br />
es_abc :: "(arbol => 'a) => arbol => bool<br />
tal que (es_abc f a) se verifica si a es un árbol binario completo<br />
respecto de f.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun es_abc :: "(arbol => 'a) => arbol => bool" where<br />
"es_abc f t = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,<br />
size (N (N H H) (N H H)) = 3<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
value "size (N (N H H) (N H H))"<br />
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. Tenemos 3 funciones de medida sobre los árboles: número de<br />
hojas, número de nodos y profundidad. A cada una le corresponde un<br />
concepto de completitud. En los siguientes ejercicios demostraremos<br />
que los tres conceptos de completitud son iguales.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de hojas.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del<br />
número de hojas syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que si a es un árbolo binario completo<br />
respecto de la profundidad, entonces a es (abc (profundidad a)).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de <br />
(es_abc size).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_8&diff=396
Relación 8
2014-01-10T01:39:19Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R8: Árboles binarios completos *}<br />
<br />
theory R8_Arboles_binarios_completos<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que no tienen información ni en los nodos y ni en las<br />
hojas. Por ejemplo, el árbol<br />
·<br />
/ \<br />
/ \<br />
· ·<br />
/ \ / \<br />
· · · · <br />
se representa por "N (N H H) (N H H)".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype arbol = H | N arbol arbol<br />
<br />
value "N (N H H) (N H H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función<br />
hojas :: "arbol => nat" <br />
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,<br />
hojas (N (N H H) (N H H)) = 4<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun hojas :: "arbol => nat" where<br />
"hojas H = Suc 0"<br />
| "hojas (N i d) = hojas i + hojas d"<br />
<br />
value "hojas (N (N H H) (N H H))" -- "= 4"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función<br />
profundidad :: "arbol => nat" <br />
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,<br />
profundidad (N (N H H) (N H H)) = 2<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun profundidad :: "arbol => nat" where<br />
"profundidad H = 0"<br />
| "profundidad (N i d) = (if profundidad i > profundidad d then Suc (profundidad i) else Suc (profundidad d))"<br />
<br />
value "profundidad (N (N H H) (N H H))" -- "= 2"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función<br />
abc :: "nat ⇒ arbol" <br />
tal que (abc n) es el árbol binario completo de profundidad n. Por<br />
ejemplo, <br />
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun abc :: "nat ⇒ arbol" where<br />
"abc 0 = undefined"<br />
<br />
value "abc 3" -- "= N (N (N H H) (N H H)) (N (N H H) (N H H))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si<br />
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i<br />
como d son árboles binarios completos respecto de f y, además, <br />
f(i) = f(r).<br />
<br />
Definir la función<br />
es_abc :: "(arbol => 'a) => arbol => bool<br />
tal que (es_abc f a) se verifica si a es un árbol binario completo<br />
respecto de f.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun es_abc :: "(arbol => 'a) => arbol => bool" where<br />
"es_abc f t = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,<br />
size (N (N H H) (N H H)) = 3<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
value "size (N (N H H) (N H H))"<br />
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. Tenemos 3 funciones de medida sobre los árboles: número de<br />
hojas, número de nodos y profundidad. A cada una le corresponde un<br />
concepto de completitud. En los siguientes ejercicios demostraremos<br />
que los tres conceptos de completitud son iguales.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de hojas.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del<br />
número de hojas syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que si a es un árbolo binario completo<br />
respecto de la profundidad, entonces a es (abc (profundidad a)).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de <br />
(es_abc size).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_8&diff=395
Relación 8
2014-01-10T01:13:31Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R8: Árboles binarios completos *}<br />
<br />
theory R8_Arboles_binarios_completos<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que no tienen información ni en los nodos y ni en las<br />
hojas. Por ejemplo, el árbol<br />
·<br />
/ \<br />
/ \<br />
· ·<br />
/ \ / \<br />
· · · · <br />
se representa por "N (N H H) (N H H)".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype arbol = H | N arbol arbol<br />
<br />
value "N (N H H) (N H H)"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función<br />
hojas :: "arbol => nat" <br />
tal que (hojas a) es el número de hojas del árbol a. Por ejemplo,<br />
hojas (N (N H H) (N H H)) = 4<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
--"diecabmen1"<br />
fun hojas :: "arbol => nat" where<br />
"hojas H = Suc 0"<br />
| "hojas (N i d) = hojas i + hojas d"<br />
<br />
value "hojas (N (N H H) (N H H))" -- "= 4"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función<br />
profundidad :: "arbol => nat" <br />
tal que (profundidad a) es la profundidad del árbol a. Por ejemplo,<br />
profundidad (N (N H H) (N H H)) = 2<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun profundidad :: "arbol => nat" where<br />
"profundidad t = undefined"<br />
<br />
value "profundidad (N (N H H) (N H H))" -- "= 2"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función<br />
abc :: "nat ⇒ arbol" <br />
tal que (abc n) es el árbol binario completo de profundidad n. Por<br />
ejemplo, <br />
abc 3 = N (N (N H H) (N H H)) (N (N H H) (N H H))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun abc :: "nat ⇒ arbol" where<br />
"abc 0 = undefined"<br />
<br />
value "abc 3" -- "= N (N (N H H) (N H H)) (N (N H H) (N H H))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Un árbol binario a es completo respecto de la medida f si<br />
a es una hoja o bien a es de la forma (N i d) y se cumple que tanto i<br />
como d son árboles binarios completos respecto de f y, además, <br />
f(i) = f(r).<br />
<br />
Definir la función<br />
es_abc :: "(arbol => 'a) => arbol => bool<br />
tal que (es_abc f a) se verifica si a es un árbol binario completo<br />
respecto de f.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun es_abc :: "(arbol => 'a) => arbol => bool" where<br />
"es_abc f t = undefined"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. (size a) es el número de nodos del árbol a. Por ejemplo,<br />
size (N (N H H) (N H H)) = 3<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
value "size (N (N H H) (N H H))"<br />
value "size (N (N (N H H) (N H H)) (N (N H H) (N H H)))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Nota. Tenemos 3 funciones de medida sobre los árboles: número de<br />
hojas, número de nodos y profundidad. A cada una le corresponde un<br />
concepto de completitud. En los siguientes ejercicios demostraremos<br />
que los tres conceptos de completitud son iguales.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de hojas.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que un árbol binario a es completo respecto del<br />
número de hojas syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Demostrar que un árbol binario a es completo respecto de<br />
la profundidad syss es completo respecto del número de nodos<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Demostrar que (abc n) es un árbol binario completo.<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Demostrar que si a es un árbolo binario completo<br />
respecto de la profundidad, entonces a es (abc (profundidad a)).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Encontrar una medida f tal que (es_abc f) es distinto de <br />
(es_abc size).<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=364
Relación 7
2013-12-24T01:00:19Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = raiz a"<br />
quickcheck<br />
oops<br />
(* Quickcheck found a counterexample:<br />
<br />
a = N a⇩1 (H a⇩2) (H a⇩1)<br />
<br />
Evaluated terms:<br />
hd (inOrden a) = a⇩2<br />
raiz a = a⇩1 *)<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "last (postOrden a) = raiz a"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "last (postOrden a) = raiz a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
thm postOrden.simps<br />
thm hd.simps<br />
thm raiz.simps<br />
have " last (postOrden (N a1 a2 a3)) = last (postOrden a2 @ postOrden a3 @ [a1])" by simp<br />
also have "… = last ([a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=363
Relación 7
2013-12-24T00:52:49Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = raiz a"<br />
quickcheck<br />
oops<br />
(* Quickcheck found a counterexample:<br />
<br />
a = N a⇩1 (H a⇩2) (H a⇩1)<br />
<br />
Evaluated terms:<br />
hd (inOrden a) = a⇩2<br />
raiz a = a⇩1 *)<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=362
Relación 7
2013-12-24T00:49:07Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = raiz a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=361
Relación 7
2013-12-24T00:42:43Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "hd (preOrden a) = last (postOrden a)"(is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have " hd (preOrden (N a1 a2 a3)) = hd (a1 # preOrden a2)" by simp<br />
also have "… = a1" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=360
Relación 7
2013-12-24T00:33:42Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=359
Relación 7
2013-12-24T00:05:49Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
by (induct a) (auto simp add: inOrdenNN)<br />
<br />
-- "diecabmen1"<br />
theorem "hd (inOrden a) = extremo_izquierda a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
thm hd.simps<br />
have "hd (inOrden (N a1 a2 a3)) = hd (inOrden a2 @ a1 # inOrden a3)" by simp<br />
also have "… = hd (inOrden a2)" by (simp add: inOrdenNN)<br />
also have "… = extremo_izquierda a2" using HI1 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=358
Relación 7
2013-12-23T23:55:16Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma inOrdenNN: "inOrden a ≠ []"<br />
by (induct a) auto<br />
<br />
theorem "last (inOrden a) = extremo_derecha a" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof - <br />
have "last (inOrden (N a1 a2 a3)) = last (a1 # inOrden a3)" by simp<br />
also have "… = last (inOrden a3)" by (simp add: inOrdenNN)<br />
also have "… = extremo_derecha a3" using HI2 by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=357
Relación 7
2013-12-21T21:06:39Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha (H x) = x"<br />
| "extremo_derecha (N x i d) = extremo_derecha d"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=356
Relación 7
2013-12-21T21:05:10Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda (H x) = x"<br />
| "extremo_izquierda (N x i d) = extremo_izquierda i"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=355
Relación 7
2013-12-21T21:02:30Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda t = undefined"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=354
Relación 7
2013-12-21T21:02:07Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz (H x) = x"<br />
| "raiz (N x i d) = x"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda t = undefined"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=353
Relación 7
2013-12-21T20:56:01Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
theorem "inOrden (espejo a) = rev (inOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "inOrden (espejo (N a1 a2 a3)) = inOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = inOrden (espejo a3) @ [a1] @ inOrden (espejo a2)" by simp<br />
also have "… = rev (inOrden a3) @ rev [a1] @ rev (inOrden a2)" using HI1 HI2 by simp<br />
also have "… = rev (inOrden a2 @ [a1] @ inOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz t = undefined"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda t = undefined"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=352
Relación 7
2013-12-21T20:33:21Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz t = undefined"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda t = undefined"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1
https://www.glc.us.es/~jalonso/RA2013/index.php?title=Relaci%C3%B3n_7&diff=351
Relación 7
2013-12-21T20:28:53Z
<p>Diecabmen1: </p>
<hr />
<div><source lang="isar"><br />
header {* R7: Recorridos de árboles *}<br />
<br />
theory R7<br />
imports Main <br />
begin <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 1. Definir el tipo de datos arbol para representar los<br />
árboles binarios que tiene información en los nodos y en las hojas. <br />
Por ejemplo, el árbol<br />
e<br />
/ \<br />
/ \<br />
c g<br />
/ \ / \<br />
a d f h <br />
se representa por "N e (N c (H a) (H d)) (N g (H f) (H h))".<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
datatype 'a arbol = H "'a" | N "'a" "'a arbol" "'a arbol"<br />
<br />
value "N e (N c (H a) (H d)) (N g (H f) (H h))" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 2. Definir la función <br />
preOrden :: "'a arbol ⇒ 'a list"<br />
tal que (preOrden a) es el recorrido pre orden del árbol a. Por<br />
ejemplo, <br />
preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [e,c,a,d,g,f,h] <br />
--------------------------------------------------------------------- <br />
*}<br />
-- "diecabmen1"<br />
<br />
fun preOrden :: "'a arbol ⇒ 'a list" where<br />
"preOrden (H x) = [x]"<br />
| "preOrden (N x i d) = [x] @ (preOrden i) @ (preOrden d)"<br />
<br />
value "preOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "= [e,c,a,d,g,f,h]" <br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 3. Definir la función <br />
postOrden :: "'a arbol ⇒ 'a list"<br />
tal que (postOrden a) es el recorrido post orden del árbol a. Por<br />
ejemplo, <br />
postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,d,c,f,h,g,e]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun postOrden :: "'a arbol ⇒ 'a list" where<br />
"postOrden (H x) = [x]"<br />
| "postOrden (N x i d) = (postOrden i) @ (postOrden d) @ [x]"<br />
<br />
value "postOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,d,c,f,h,g,e]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 4. Definir la función <br />
inOrden :: "'a arbol ⇒ 'a list"<br />
tal que (inOrden a) es el recorrido in orden del árbol a. Por<br />
ejemplo, <br />
inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= [a,c,d,e,f,g,h]<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun inOrden :: "'a arbol ⇒ 'a list" where<br />
"inOrden (H x) = [x]"<br />
| "inOrden (N x i d) = (inOrden i) @ [x] @ (inOrden d)"<br />
<br />
value "inOrden (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "[a,c,d,e,f,g,h]"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 5. Definir la función <br />
espejo :: "'a arbol ⇒ 'a arbol"<br />
tal que (espejo a) es la imagen especular del árbol a. Por ejemplo, <br />
espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))<br />
= N e (N g (H h) (H f)) (N c (H d) (H a))<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
fun espejo :: "'a arbol ⇒ 'a arbol" where<br />
"espejo (H x) = (H x)"<br />
| "espejo (N x i d) = (N x (espejo d) (espejo i))"<br />
<br />
value "espejo (N e (N c (H a) (H d)) (N g (H f) (H h)))" <br />
-- "N e (N g (H h) (H f)) (N c (H d) (H a))"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 6. Demostrar que<br />
preOrden (espejo a) = rev (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "preOrden (espejo a) = rev (postOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
have "preOrden (espejo (N a1 a2 a3)) = preOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = [a1] @ preOrden (espejo a3) @ preOrden (espejo a2)" by simp<br />
also have "… = rev [a1] @ rev (postOrden a3) @ rev (postOrden a2)" using HI1 HI2 by simp <br />
also have "… = rev ((postOrden a2) @ (postOrden a3) @ [a1])" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 7. Demostrar que<br />
postOrden (espejo a) = rev (preOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)"<br />
by (induct a) auto<br />
<br />
-- "diecabmen1"<br />
lemma "postOrden (espejo a) = rev (preOrden a)" (is "?P a")<br />
proof (induct a)<br />
fix x<br />
show "?P (H x)" by simp<br />
next<br />
fix a1 a2 a3<br />
assume HI1: "?P a2"<br />
assume HI2: "?P a3"<br />
show "?P (N a1 a2 a3)"<br />
proof -<br />
thm postOrden.simps<br />
thm preOrden.simps<br />
have "postOrden (espejo (N a1 a2 a3)) = postOrden (N a1 (espejo a3) (espejo a2))" by simp<br />
also have "… = postOrden (espejo a3) @ postOrden (espejo a2) @ [a1]" by simp<br />
also have "… = rev (preOrden a3) @ rev (preOrden a2) @ rev [a1]" using HI1 HI2 by simp<br />
also have "… = rev ([a1] @ preOrden a2 @ preOrden a3)" by simp<br />
finally show ?thesis by simp<br />
qed<br />
qed<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 8. Demostrar que<br />
inOrden (espejo a) = rev (inOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "inOrden (espejo a) = rev (inOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 9. Definir la función <br />
raiz :: "'a arbol ⇒ 'a"<br />
tal que (raiz a) es la raiz del árbol a. Por ejemplo, <br />
raiz (N e (N c (H a) (H d)) (N g (H f) (H h))) = e<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun raiz :: "'a arbol ⇒ 'a" where<br />
"raiz t = undefined"<br />
<br />
value "raiz (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= e"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 10. Definir la función <br />
extremo_izquierda :: "'a arbol ⇒ 'a"<br />
tal que (extremo_izquierda a) es el nodo más a la izquierda del árbol<br />
a. Por ejemplo, <br />
extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h))) = a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_izquierda :: "'a arbol ⇒ 'a" where<br />
"extremo_izquierda t = undefined"<br />
<br />
value "extremo_izquierda (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= a"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 11. Definir la función <br />
extremo_derecha :: "'a arbol ⇒ 'a"<br />
tal que (extremo_derecha a) es el nodo más a la derecha del árbol<br />
a. Por ejemplo, <br />
extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h))) = h<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
fun extremo_derecha :: "'a arbol ⇒ 'a" where<br />
"extremo_derecha t = undefined"<br />
<br />
value "extremo_derecha (N e (N c (H a) (H d)) (N g (H f) (H h)))" -- "= h"<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 12. Demostrar o refutar<br />
last (inOrden a) = extremo_derecha a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (inOrden a) = extremo_derecha a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 13. Demostrar o refutar<br />
hd (inOrden a) = extremo_izquierda a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = extremo_izquierda a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 14. Demostrar o refutar<br />
hd (preOrden a) = last (postOrden a)<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = last (postOrden a)"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 15. Demostrar o refutar<br />
hd (preOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (preOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 16. Demostrar o refutar<br />
hd (inOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "hd (inOrden a) = raiz a"<br />
oops<br />
<br />
text {* <br />
--------------------------------------------------------------------- <br />
Ejercicio 17. Demostrar o refutar<br />
last (postOrden a) = raiz a<br />
--------------------------------------------------------------------- <br />
*}<br />
<br />
theorem "last (postOrden a) = raiz a"<br />
oops<br />
<br />
end<br />
</source></div>
Diecabmen1