https://www.glc.us.es/~jalonso/LMF2013/api.php?action=feedcontributions&feedformat=atom&user=Isaduatos
Lógica matemática y fundamentos (2012-13) - Contribuciones del usuario [es]
2026-07-17T22:25:13Z
Contribuciones del usuario
MediaWiki 1.31.14
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_10&diff=508
Relación 10
2013-05-15T11:10:01Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- Clausulas.hs<br />
-- Cláusulas.<br />
-- ---------------------------------------------------------------------<br />
<br />
module Clausulas where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import FormasNormales<br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir el tipo de datos Cláusula como una lista de<br />
-- literales. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Cláusula = [Literal]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- cláusula :: Prop -> Cláusula<br />
-- tal que (cláusula f) es la cláusula de la fórmula-clausal f. Por<br />
-- ejemplo, <br />
-- cláusula p ==> [p]<br />
-- cláusula (no p) ==> [no p]<br />
-- cláusula (((no p) \/ r) \/ ((no p) \/ q)) ==> [q,r,no p]<br />
-- ---------------------------------------------------------------------<br />
--José M Contreras<br />
<br />
clausula :: Prop -> Clausula<br />
clausula f | literal f = [f]<br />
clausula (Disj f g)=sort((clausula f)`union`(clausula g))<br />
<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- cláusulasFNC :: Prop -> [Cláusula]<br />
-- tal que (cláusulasFNC f) es el conjunto de cláusulas de la fórmula en<br />
-- forma normal conjuntiva f. Por ejmplo,<br />
-- cláusulasFNC (p /\ ((no q) \/ r))<br />
-- ==> [[p],[r, no q]]<br />
-- cláusulasFNC (((no p) \/ q) /\ ((no p) \/ (no r)))<br />
-- ==> [[q, no p],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulasFNC :: Prop -> [Clausula]<br />
clausulasFNC (Conj f g)= union (clausulasFNC f) (clausulasFNC g) <br />
clausulasFNC f=[clausula f]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- cláusulas :: Prop -> [Cláusula]<br />
-- tal que (cláusulas f) es un conjunto de cláusulas equivalente a<br />
-- f. Por ejemplo,<br />
-- cláusulas (p /\ (q --> r)) <br />
-- ==> [[p],[r,no q]]<br />
-- cláusulas (no (p /\ (q --> r))) <br />
-- ==> [[q,no p],[no p,no r]]<br />
-- cláusulas (no(p <--> r)) <br />
-- ==> [[p,r],[p,no p],[r,no r],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulas :: Prop -> [Clausula]<br />
clausulas = clausulasFNC . formaNormalConjuntiva<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- cláusulasConjunto :: [Prop] -> [Cláusula]<br />
-- tal que (cláusulasConjunto s) es un conjunto de cláusulas equivalente<br />
-- a s. Por ejemplo,<br />
-- cláusulasConjunto [p --> q, q --> r] ==> [[q,no p],[r,no q]]<br />
-- cláusulasConjunto [p --> q, q <--> p] ==> [[q,no p],[p,no q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
clausulasConjunto :: [Prop] -> [Cláusula]<br />
clausulasConjunto s = unionGeneral [clausulas f | f <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- símbolosProposicionalesCláusula :: Cláusula -> [Prop]<br />
-- tal que (símbolosProposicionalesCláusula c) es el conjunto de los<br />
-- símbolos proposicionales de c. Por ejemplo,<br />
-- símbolosProposicionalesCláusula [p, q, no p] ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
simbolosProposicionalesClausula :: Clausula -> [Prop]<br />
simbolosProposicionalesClausula = simbolosPropConj<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]<br />
-- tal que (símbolosProposicionalesConjuntoCláusula s) es el conjunto de los<br />
-- símbolos proposicionales de s. Por ejemplo,<br />
-- símbolosProposicionalesConjuntoCláusula [[p, q],[no q, r]]<br />
-- ==> [p,q,r]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
simbolosProposicionalesConjuntoClausula :: [Cláusula] -> [Prop]<br />
simbolosProposicionalesConjuntoClausula s =<br />
unionGeneral [simbolosProposicionalesClausula c | c <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- interpretacionesCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (interpretacionesCláusula c) es el conjunto de<br />
-- interpretaciones de c. Por ejemplo,<br />
-- interpretacionesCláusula [p, q, no p] ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesCláusula [] ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesClausula :: Cláusula -> [Interpretación]<br />
interpretacionesClausula c = subconjuntos (simbolosProposicionalesClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]<br />
-- tal que (interpretacionesConjuntoCláusula s) es el conjunto de<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjuntoCláusula [[p, no q],[no p, q]]<br />
-- ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesConjuntoCláusula []<br />
-- ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesConjuntoClausula :: [Cláusula] -> [Interpretación]<br />
interpretacionesConjuntoClausula c = <br />
subconjuntos (simbolosProposicionalesConjuntoClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloLiteral :: Interpretación -> Literal -> Bool<br />
-- tal que (esModeloLiteral i l) se verifica si i es modelo de l. Por<br />
-- ejemplo, <br />
-- esModeloLiteral [p,r] p ==> True<br />
-- esModeloLiteral [p,r] q ==> False<br />
-- esModeloLiteral [p,r] (no p) ==> False<br />
-- esModeloLiteral [p,r] (no q) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloLiteral :: Interpretacion -> Literal -> Bool<br />
esModeloLiteral i (Atom s) = elem (Atom s) i<br />
esModeloLiteral i (Neg (Atom s)) = notElem (Atom s) i<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- esModeloCláusula :: Interpretación -> Cláusula -> Bool<br />
-- tal que (esModeloCláusula i c) se verifica si i es modelo de c . Por<br />
-- ejemplo, <br />
-- esModeloCláusula [p,r] [p, q] ==> True<br />
-- esModeloCláusula [r] [p, no q] ==> True<br />
-- esModeloCláusula [q,r] [p, no q] ==> False<br />
-- esModeloCláusula [q,r] [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloClausula :: Interpretacion -> Clausula -> Bool<br />
esModeloClausula i c = or [esModeloLiteral i p | p <- c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- modelosCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (modelosCláusula c) es la lista de los modelos de c. Por<br />
-- ejemplo, <br />
-- modelosCláusula [no p, q] ==> [[p,q],[q],[]]<br />
-- modelosCláusula [no p, p] ==> [[p],[]]<br />
-- modelosCláusula [] ==> []<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
modelosClausula :: Clausula -> [Interpretacion]<br />
modelosClausula c = [ x | x <- (interpretacionesClausula c), esModeloClausula x c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
-- tal que (esModeloConjuntoCláusulas i c) se verifica si i es modelo de<br />
-- c. Por ejemplo,<br />
-- esModeloConjuntoCláusulas [p,r] [[p, no q], [r]] ==> True<br />
-- esModeloConjuntoCláusulas [p] [[p, no q], [r]] ==> False<br />
-- esModeloConjuntoCláusulas [p] [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
esModeloConjuntoCláusulas i s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
-- tal que (modelosConjuntoCláusulas s) es la lista de los modelos de<br />
-- s. Por ejemplo, <br />
-- modelosConjuntoCláusulas [[no p, q], [no q, p]] <br />
-- ==> [[p,q],[]]<br />
-- modelosConjuntoCláusulas [[no p, q], [p], [no q]] <br />
-- ==> []<br />
-- modelosConjuntoCláusulas [[p, no p, q]] <br />
-- ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
modelosConjuntoCláusulas s = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esCláusulaVálida :: Cláusula -> Bool<br />
-- tal que (esCláusulaVálida c) se verifica si la cláusula c es<br />
-- válida. Por ejemplo, <br />
-- esCláusulaVálida [p, q, no p] ==> True<br />
-- esCláusulaVálida [p, q, no r] ==> False<br />
-- esCláusulaVálida [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaVálida :: Cláusula -> Bool<br />
esCláusulaVálida c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- esCláusulaInsatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaInsatisfacible c) se verifica si la cláusula c es<br />
-- insatisfacible. Por ejemplo, <br />
-- esCláusulaInsatisfacible [p, q, no p] ==> False<br />
-- esCláusulaInsatisfacible [p, q, no r] ==> False<br />
-- esCláusulaInsatisfacible [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaInsatisfacible :: Cláusula -> Bool<br />
esCláusulaInsatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- esCláusulaSatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaSatisfacible c) se verifica si la cláusula c es<br />
-- satisfacible. Por ejemplo, <br />
-- esCláusulaSatisfacible [p, q, no p] ==> True<br />
-- esCláusulaSatisfacible [p, q, no r] ==> True<br />
-- esCláusulaSatisfacible [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaSatisfacible :: Cláusula -> Bool<br />
esCláusulaSatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos válidos, consistentes e inconsistentes de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoVálidoDeCláusulas s) se verifica si el conjunto de<br />
-- cláusulas s es válido. Por ejemplo,<br />
-- esConjuntoVálidoDeCláusulas [[no p, q], [no q, p]] ==> False<br />
-- esConjuntoVálidoDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoVálidoDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoVálidoDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoConsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoConsistenteDeCláusulas [[no p, q], [no q, p]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoConsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoInconsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoInconsistenteDeCláusulas [[no p,q],[no q,p]] ==> False<br />
-- esConjuntoInconsistenteDeCláusulas [[no p],[p]] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoInconsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Validez de fórmulas mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esVálidaPorCláusulas :: Prop -> Bool<br />
-- tal que (esVálidaPorCláusulas f) se verifica si el conjunto de<br />
-- cláusulas de f es válido. Por ejemplo,<br />
-- esVálidaPorCláusulas (p --> q) ==> False<br />
-- esVálidaPorCláusulas (p --> p) ==> True<br />
-- esVálidaPorCláusulas ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esVálidaPorCláusulas :: Prop -> Bool<br />
esVálidaPorCláusulas f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
-- tal que (esConsecuenciaEntreCláusulas s1 s2) se verifica si todos los<br />
-- modelos de s1 son modelos de s2. Por ejemplo,<br />
-- esConsecuenciaEntreCláusulas [[no p,q],[no q,r]] [[no p,r]] <br />
-- ==> True<br />
-- esConsecuenciaEntreCláusulas [[p]] [[p],[q]] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
esConsecuenciaEntreCláusulas s1 s2 = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 23: Definir la función<br />
-- esConsecuenciaPorCláusulas1 :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuenciaPorCláusulas s f) se verifica si las cláusulas<br />
-- de f son consecuencias de las de s. Por ejemplo,<br />
-- esConsecuenciaPorCláusulas [(p --> q), (q --> r)] (p --> r)<br />
-- ==> True<br />
-- esConsecuenciaPorCláusulas [p] (p /\ q)<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool<br />
esConsecuenciaPorCláusulas s f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_10&diff=507
Relación 10
2013-05-15T11:07:45Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- Clausulas.hs<br />
-- Cláusulas.<br />
-- ---------------------------------------------------------------------<br />
<br />
module Clausulas where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import FormasNormales<br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir el tipo de datos Cláusula como una lista de<br />
-- literales. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Cláusula = [Literal]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- cláusula :: Prop -> Cláusula<br />
-- tal que (cláusula f) es la cláusula de la fórmula-clausal f. Por<br />
-- ejemplo, <br />
-- cláusula p ==> [p]<br />
-- cláusula (no p) ==> [no p]<br />
-- cláusula (((no p) \/ r) \/ ((no p) \/ q)) ==> [q,r,no p]<br />
-- ---------------------------------------------------------------------<br />
--José M Contreras<br />
<br />
clausula :: Prop -> Clausula<br />
clausula f | literal f = [f]<br />
clausula (Disj f g)=sort((clausula f)`union`(clausula g))<br />
<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- cláusulasFNC :: Prop -> [Cláusula]<br />
-- tal que (cláusulasFNC f) es el conjunto de cláusulas de la fórmula en<br />
-- forma normal conjuntiva f. Por ejmplo,<br />
-- cláusulasFNC (p /\ ((no q) \/ r))<br />
-- ==> [[p],[r, no q]]<br />
-- cláusulasFNC (((no p) \/ q) /\ ((no p) \/ (no r)))<br />
-- ==> [[q, no p],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulasFNC :: Prop -> [Clausula]<br />
clausulasFNC (Conj f g)= union (clausulasFNC f) (clausulasFNC g) <br />
clausulasFNC f=[clausula f]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- cláusulas :: Prop -> [Cláusula]<br />
-- tal que (cláusulas f) es un conjunto de cláusulas equivalente a<br />
-- f. Por ejemplo,<br />
-- cláusulas (p /\ (q --> r)) <br />
-- ==> [[p],[r,no q]]<br />
-- cláusulas (no (p /\ (q --> r))) <br />
-- ==> [[q,no p],[no p,no r]]<br />
-- cláusulas (no(p <--> r)) <br />
-- ==> [[p,r],[p,no p],[r,no r],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulas :: Prop -> [Clausula]<br />
clausulas = clausulasFNC . formaNormalConjuntiva<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- cláusulasConjunto :: [Prop] -> [Cláusula]<br />
-- tal que (cláusulasConjunto s) es un conjunto de cláusulas equivalente<br />
-- a s. Por ejemplo,<br />
-- cláusulasConjunto [p --> q, q --> r] ==> [[q,no p],[r,no q]]<br />
-- cláusulasConjunto [p --> q, q <--> p] ==> [[q,no p],[p,no q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
clausulasConjunto :: [Prop] -> [Cláusula]<br />
clausulasConjunto s = unionGeneral [clausulas f | f <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- símbolosProposicionalesCláusula :: Cláusula -> [Prop]<br />
-- tal que (símbolosProposicionalesCláusula c) es el conjunto de los<br />
-- símbolos proposicionales de c. Por ejemplo,<br />
-- símbolosProposicionalesCláusula [p, q, no p] ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
símbolosProposicionalesCláusula :: Cláusula -> [Prop]<br />
símbolosProposicionalesCláusula = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]<br />
-- tal que (símbolosProposicionalesConjuntoCláusula s) es el conjunto de los<br />
-- símbolos proposicionales de s. Por ejemplo,<br />
-- símbolosProposicionalesConjuntoCláusula [[p, q],[no q, r]]<br />
-- ==> [p,q,r]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
simbolosProposicionalesConjuntoClausula :: [Cláusula] -> [Prop]<br />
simbolosProposicionalesConjuntoClausula s =<br />
unionGeneral [simbolosProposicionalesClausula c | c <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- interpretacionesCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (interpretacionesCláusula c) es el conjunto de<br />
-- interpretaciones de c. Por ejemplo,<br />
-- interpretacionesCláusula [p, q, no p] ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesCláusula [] ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesClausula :: Cláusula -> [Interpretación]<br />
interpretacionesClausula c = subconjuntos (simbolosProposicionalesClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]<br />
-- tal que (interpretacionesConjuntoCláusula s) es el conjunto de<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjuntoCláusula [[p, no q],[no p, q]]<br />
-- ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesConjuntoCláusula []<br />
-- ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesConjuntoClausula :: [Cláusula] -> [Interpretación]<br />
interpretacionesConjuntoClausula c = <br />
subconjuntos (simbolosProposicionalesConjuntoClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloLiteral :: Interpretación -> Literal -> Bool<br />
-- tal que (esModeloLiteral i l) se verifica si i es modelo de l. Por<br />
-- ejemplo, <br />
-- esModeloLiteral [p,r] p ==> True<br />
-- esModeloLiteral [p,r] q ==> False<br />
-- esModeloLiteral [p,r] (no p) ==> False<br />
-- esModeloLiteral [p,r] (no q) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloLiteral :: Interpretacion -> Literal -> Bool<br />
esModeloLiteral i (Atom s) = elem (Atom s) i<br />
esModeloLiteral i (Neg (Atom s)) = notElem (Atom s) i<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- esModeloCláusula :: Interpretación -> Cláusula -> Bool<br />
-- tal que (esModeloCláusula i c) se verifica si i es modelo de c . Por<br />
-- ejemplo, <br />
-- esModeloCláusula [p,r] [p, q] ==> True<br />
-- esModeloCláusula [r] [p, no q] ==> True<br />
-- esModeloCláusula [q,r] [p, no q] ==> False<br />
-- esModeloCláusula [q,r] [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloClausula :: Interpretacion -> Clausula -> Bool<br />
esModeloClausula i c = or [esModeloLiteral i p | p <- c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- modelosCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (modelosCláusula c) es la lista de los modelos de c. Por<br />
-- ejemplo, <br />
-- modelosCláusula [no p, q] ==> [[p,q],[q],[]]<br />
-- modelosCláusula [no p, p] ==> [[p],[]]<br />
-- modelosCláusula [] ==> []<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
modelosClausula :: Clausula -> [Interpretacion]<br />
modelosClausula c = [ x | x <- (interpretacionesClausula c), esModeloClausula x c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
-- tal que (esModeloConjuntoCláusulas i c) se verifica si i es modelo de<br />
-- c. Por ejemplo,<br />
-- esModeloConjuntoCláusulas [p,r] [[p, no q], [r]] ==> True<br />
-- esModeloConjuntoCláusulas [p] [[p, no q], [r]] ==> False<br />
-- esModeloConjuntoCláusulas [p] [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
esModeloConjuntoCláusulas i s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
-- tal que (modelosConjuntoCláusulas s) es la lista de los modelos de<br />
-- s. Por ejemplo, <br />
-- modelosConjuntoCláusulas [[no p, q], [no q, p]] <br />
-- ==> [[p,q],[]]<br />
-- modelosConjuntoCláusulas [[no p, q], [p], [no q]] <br />
-- ==> []<br />
-- modelosConjuntoCláusulas [[p, no p, q]] <br />
-- ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
modelosConjuntoCláusulas s = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esCláusulaVálida :: Cláusula -> Bool<br />
-- tal que (esCláusulaVálida c) se verifica si la cláusula c es<br />
-- válida. Por ejemplo, <br />
-- esCláusulaVálida [p, q, no p] ==> True<br />
-- esCláusulaVálida [p, q, no r] ==> False<br />
-- esCláusulaVálida [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaVálida :: Cláusula -> Bool<br />
esCláusulaVálida c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- esCláusulaInsatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaInsatisfacible c) se verifica si la cláusula c es<br />
-- insatisfacible. Por ejemplo, <br />
-- esCláusulaInsatisfacible [p, q, no p] ==> False<br />
-- esCláusulaInsatisfacible [p, q, no r] ==> False<br />
-- esCláusulaInsatisfacible [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaInsatisfacible :: Cláusula -> Bool<br />
esCláusulaInsatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- esCláusulaSatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaSatisfacible c) se verifica si la cláusula c es<br />
-- satisfacible. Por ejemplo, <br />
-- esCláusulaSatisfacible [p, q, no p] ==> True<br />
-- esCláusulaSatisfacible [p, q, no r] ==> True<br />
-- esCláusulaSatisfacible [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaSatisfacible :: Cláusula -> Bool<br />
esCláusulaSatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos válidos, consistentes e inconsistentes de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoVálidoDeCláusulas s) se verifica si el conjunto de<br />
-- cláusulas s es válido. Por ejemplo,<br />
-- esConjuntoVálidoDeCláusulas [[no p, q], [no q, p]] ==> False<br />
-- esConjuntoVálidoDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoVálidoDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoVálidoDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoConsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoConsistenteDeCláusulas [[no p, q], [no q, p]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoConsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoInconsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoInconsistenteDeCláusulas [[no p,q],[no q,p]] ==> False<br />
-- esConjuntoInconsistenteDeCláusulas [[no p],[p]] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoInconsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Validez de fórmulas mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esVálidaPorCláusulas :: Prop -> Bool<br />
-- tal que (esVálidaPorCláusulas f) se verifica si el conjunto de<br />
-- cláusulas de f es válido. Por ejemplo,<br />
-- esVálidaPorCláusulas (p --> q) ==> False<br />
-- esVálidaPorCláusulas (p --> p) ==> True<br />
-- esVálidaPorCláusulas ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esVálidaPorCláusulas :: Prop -> Bool<br />
esVálidaPorCláusulas f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
-- tal que (esConsecuenciaEntreCláusulas s1 s2) se verifica si todos los<br />
-- modelos de s1 son modelos de s2. Por ejemplo,<br />
-- esConsecuenciaEntreCláusulas [[no p,q],[no q,r]] [[no p,r]] <br />
-- ==> True<br />
-- esConsecuenciaEntreCláusulas [[p]] [[p],[q]] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
esConsecuenciaEntreCláusulas s1 s2 = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 23: Definir la función<br />
-- esConsecuenciaPorCláusulas1 :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuenciaPorCláusulas s f) se verifica si las cláusulas<br />
-- de f son consecuencias de las de s. Por ejemplo,<br />
-- esConsecuenciaPorCláusulas [(p --> q), (q --> r)] (p --> r)<br />
-- ==> True<br />
-- esConsecuenciaPorCláusulas [p] (p /\ q)<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool<br />
esConsecuenciaPorCláusulas s f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_10&diff=506
Relación 10
2013-05-15T11:06:58Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- Clausulas.hs<br />
-- Cláusulas.<br />
-- ---------------------------------------------------------------------<br />
<br />
module Clausulas where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import FormasNormales<br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir el tipo de datos Cláusula como una lista de<br />
-- literales. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Cláusula = [Literal]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- cláusula :: Prop -> Cláusula<br />
-- tal que (cláusula f) es la cláusula de la fórmula-clausal f. Por<br />
-- ejemplo, <br />
-- cláusula p ==> [p]<br />
-- cláusula (no p) ==> [no p]<br />
-- cláusula (((no p) \/ r) \/ ((no p) \/ q)) ==> [q,r,no p]<br />
-- ---------------------------------------------------------------------<br />
--José M Contreras<br />
<br />
clausula :: Prop -> Clausula<br />
clausula f | literal f = [f]<br />
clausula (Disj f g)=sort((clausula f)`union`(clausula g))<br />
<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- cláusulasFNC :: Prop -> [Cláusula]<br />
-- tal que (cláusulasFNC f) es el conjunto de cláusulas de la fórmula en<br />
-- forma normal conjuntiva f. Por ejmplo,<br />
-- cláusulasFNC (p /\ ((no q) \/ r))<br />
-- ==> [[p],[r, no q]]<br />
-- cláusulasFNC (((no p) \/ q) /\ ((no p) \/ (no r)))<br />
-- ==> [[q, no p],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulasFNC :: Prop -> [Clausula]<br />
clausulasFNC (Conj f g)= union (clausulasFNC f) (clausulasFNC g) <br />
clausulasFNC f=[clausula f]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- cláusulas :: Prop -> [Cláusula]<br />
-- tal que (cláusulas f) es un conjunto de cláusulas equivalente a<br />
-- f. Por ejemplo,<br />
-- cláusulas (p /\ (q --> r)) <br />
-- ==> [[p],[r,no q]]<br />
-- cláusulas (no (p /\ (q --> r))) <br />
-- ==> [[q,no p],[no p,no r]]<br />
-- cláusulas (no(p <--> r)) <br />
-- ==> [[p,r],[p,no p],[r,no r],[no p,no r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--José M Contreras<br />
<br />
clausulas :: Prop -> [Clausula]<br />
clausulas = clausulasFNC . formaNormalConjuntiva<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- cláusulasConjunto :: [Prop] -> [Cláusula]<br />
-- tal que (cláusulasConjunto s) es un conjunto de cláusulas equivalente<br />
-- a s. Por ejemplo,<br />
-- cláusulasConjunto [p --> q, q --> r] ==> [[q,no p],[r,no q]]<br />
-- cláusulasConjunto [p --> q, q <--> p] ==> [[q,no p],[p,no q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
clausulasConjunto :: [Prop] -> [Cláusula]<br />
clausulasConjunto s = unionGeneral [clausulas f | f <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- símbolosProposicionalesCláusula :: Cláusula -> [Prop]<br />
-- tal que (símbolosProposicionalesCláusula c) es el conjunto de los<br />
-- símbolos proposicionales de c. Por ejemplo,<br />
-- símbolosProposicionalesCláusula [p, q, no p] ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
símbolosProposicionalesCláusula :: Cláusula -> [Prop]<br />
símbolosProposicionalesCláusula = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]<br />
-- tal que (símbolosProposicionalesConjuntoCláusula s) es el conjunto de los<br />
-- símbolos proposicionales de s. Por ejemplo,<br />
-- símbolosProposicionalesConjuntoCláusula [[p, q],[no q, r]]<br />
-- ==> [p,q,r]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
simbolosProposicionalesConjuntoClausula :: [Cláusula] -> [Prop]<br />
simbolosProposicionalesConjuntoClausula s =<br />
unionGeneral [simbolosProposicionalesClausula c | c <- s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una cláusula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- interpretacionesCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (interpretacionesCláusula c) es el conjunto de<br />
-- interpretaciones de c. Por ejemplo,<br />
-- interpretacionesCláusula [p, q, no p] ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesCláusula [] ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesClausula :: Cláusula -> [Interpretación]<br />
interpretacionesClausula c = subconjuntos (simbolosProposicionalesClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]<br />
-- tal que (interpretacionesConjuntoCláusula s) es el conjunto de<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjuntoCláusula [[p, no q],[no p, q]]<br />
-- ==> [[p,q],[p],[q],[]]<br />
-- interpretacionesConjuntoCláusula []<br />
-- ==> [[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
interpretacionesConjuntoClausula :: [Cláusula] -> [Interpretación]<br />
interpretacionesConjuntoCláusula c = <br />
subconjuntos (simbolosProposicionalesConjuntoClausula c)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloLiteral :: Interpretación -> Literal -> Bool<br />
-- tal que (esModeloLiteral i l) se verifica si i es modelo de l. Por<br />
-- ejemplo, <br />
-- esModeloLiteral [p,r] p ==> True<br />
-- esModeloLiteral [p,r] q ==> False<br />
-- esModeloLiteral [p,r] (no p) ==> False<br />
-- esModeloLiteral [p,r] (no q) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloLiteral :: Interpretacion -> Literal -> Bool<br />
esModeloLiteral i (Atom s) = elem (Atom s) i<br />
esModeloLiteral i (Neg (Atom s)) = notElem (Atom s) i<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- esModeloCláusula :: Interpretación -> Cláusula -> Bool<br />
-- tal que (esModeloCláusula i c) se verifica si i es modelo de c . Por<br />
-- ejemplo, <br />
-- esModeloCláusula [p,r] [p, q] ==> True<br />
-- esModeloCláusula [r] [p, no q] ==> True<br />
-- esModeloCláusula [q,r] [p, no q] ==> False<br />
-- esModeloCláusula [q,r] [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloClausula :: Interpretacion -> Clausula -> Bool<br />
esModeloClausula i c = or [esModeloLiteral i p | p <- c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- modelosCláusula :: Cláusula -> [Interpretación]<br />
-- tal que (modelosCláusula c) es la lista de los modelos de c. Por<br />
-- ejemplo, <br />
-- modelosCláusula [no p, q] ==> [[p,q],[q],[]]<br />
-- modelosCláusula [no p, p] ==> [[p],[]]<br />
-- modelosCláusula [] ==> []<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
modelosClausula :: Clausula -> [Interpretacion]<br />
modelosClausula c = [ x | x <- (interpretacionesClausula c), esModeloClausula x c]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
-- tal que (esModeloConjuntoCláusulas i c) se verifica si i es modelo de<br />
-- c. Por ejemplo,<br />
-- esModeloConjuntoCláusulas [p,r] [[p, no q], [r]] ==> True<br />
-- esModeloConjuntoCláusulas [p] [[p, no q], [r]] ==> False<br />
-- esModeloConjuntoCláusulas [p] [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool<br />
esModeloConjuntoCláusulas i s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
-- tal que (modelosConjuntoCláusulas s) es la lista de los modelos de<br />
-- s. Por ejemplo, <br />
-- modelosConjuntoCláusulas [[no p, q], [no q, p]] <br />
-- ==> [[p,q],[]]<br />
-- modelosConjuntoCláusulas [[no p, q], [p], [no q]] <br />
-- ==> []<br />
-- modelosConjuntoCláusulas [[p, no p, q]] <br />
-- ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]<br />
modelosConjuntoCláusulas s = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Cláusulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esCláusulaVálida :: Cláusula -> Bool<br />
-- tal que (esCláusulaVálida c) se verifica si la cláusula c es<br />
-- válida. Por ejemplo, <br />
-- esCláusulaVálida [p, q, no p] ==> True<br />
-- esCláusulaVálida [p, q, no r] ==> False<br />
-- esCláusulaVálida [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaVálida :: Cláusula -> Bool<br />
esCláusulaVálida c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- esCláusulaInsatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaInsatisfacible c) se verifica si la cláusula c es<br />
-- insatisfacible. Por ejemplo, <br />
-- esCláusulaInsatisfacible [p, q, no p] ==> False<br />
-- esCláusulaInsatisfacible [p, q, no r] ==> False<br />
-- esCláusulaInsatisfacible [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaInsatisfacible :: Cláusula -> Bool<br />
esCláusulaInsatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- esCláusulaSatisfacible :: Cláusula -> Bool<br />
-- tal que (esCláusulaSatisfacible c) se verifica si la cláusula c es<br />
-- satisfacible. Por ejemplo, <br />
-- esCláusulaSatisfacible [p, q, no p] ==> True<br />
-- esCláusulaSatisfacible [p, q, no r] ==> True<br />
-- esCláusulaSatisfacible [] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esCláusulaSatisfacible :: Cláusula -> Bool<br />
esCláusulaSatisfacible c = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos válidos, consistentes e inconsistentes de cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoVálidoDeCláusulas s) se verifica si el conjunto de<br />
-- cláusulas s es válido. Por ejemplo,<br />
-- esConjuntoVálidoDeCláusulas [[no p, q], [no q, p]] ==> False<br />
-- esConjuntoVálidoDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoVálidoDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoVálidoDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoConsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoConsistenteDeCláusulas [[no p, q], [no q, p]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [[no p, p], [no q, q]] ==> True<br />
-- esConjuntoConsistenteDeCláusulas [] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoConsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
-- tal que (esConjuntoInconsistenteDeCláusulas s) se verifica si el<br />
-- conjunto de cláusulas s es consistente. Por ejemplo,<br />
-- esConjuntoInconsistenteDeCláusulas [[no p,q],[no q,p]] ==> False<br />
-- esConjuntoInconsistenteDeCláusulas [[no p],[p]] ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool<br />
esConjuntoInconsistenteDeCláusulas s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Validez de fórmulas mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esVálidaPorCláusulas :: Prop -> Bool<br />
-- tal que (esVálidaPorCláusulas f) se verifica si el conjunto de<br />
-- cláusulas de f es válido. Por ejemplo,<br />
-- esVálidaPorCláusulas (p --> q) ==> False<br />
-- esVálidaPorCláusulas (p --> p) ==> True<br />
-- esVálidaPorCláusulas ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esVálidaPorCláusulas :: Prop -> Bool<br />
esVálidaPorCláusulas f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia mediante cláusulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
-- tal que (esConsecuenciaEntreCláusulas s1 s2) se verifica si todos los<br />
-- modelos de s1 son modelos de s2. Por ejemplo,<br />
-- esConsecuenciaEntreCláusulas [[no p,q],[no q,r]] [[no p,r]] <br />
-- ==> True<br />
-- esConsecuenciaEntreCláusulas [[p]] [[p],[q]] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool<br />
esConsecuenciaEntreCláusulas s1 s2 = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 23: Definir la función<br />
-- esConsecuenciaPorCláusulas1 :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuenciaPorCláusulas s f) se verifica si las cláusulas<br />
-- de f son consecuencias de las de s. Por ejemplo,<br />
-- esConsecuenciaPorCláusulas [(p --> q), (q --> r)] (p --> r)<br />
-- ==> True<br />
-- esConsecuenciaPorCláusulas [p] (p /\ q)<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool<br />
esConsecuenciaPorCláusulas s f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_9&diff=495
Relación 9
2013-05-14T15:46:19Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- FormasNormales.hs<br />
-- Formas normales.<br />
-- ---------------------------------------------------------------------<br />
<br />
module FormasNormales where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica <br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Equivalencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- esEquivalente :: Prop -> Prop -> Bool<br />
-- tal que (esEquivalente f g) se verifica si f y g son<br />
-- equivalentes. Por ejemplo,<br />
-- esEquivalente (p <--> q) ((p --> q) /\ (q --> p)) ==> True<br />
-- esEquivalente (p --> q) ((no p) \/ q) ==> True<br />
-- esEquivalente (p /\ q) (no ((no p) \/ (no q))) ==> True<br />
-- esEquivalente (p \/ q) (no ((no p) /\ (no q))) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esEquivalente :: Prop -> Prop -> Bool<br />
esEquivalente f g = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal negativa --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- eliminaEquivalencias :: Prop -> Prop<br />
-- tal que (eliminaEquivalencias f) es una fórmula equivalente a f sin<br />
-- signos de equivalencia. Por ejemplo,<br />
-- eliminaEquivalencias (p <--> q)<br />
-- ==> ((p --> q) /\ (q --> p))<br />
-- eliminaEquivalencias ((p <--> q) /\ (q <--> r))<br />
-- ==> (((p --> q) /\ (q --> p)) /\ ((q --> r) /\ (r --> q)))<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaEquivalencias :: Prop -> Prop<br />
eliminaEquivalencias = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- eliminaImplicaciones :: Prop -> Prop<br />
-- tal que (eliminaImplicaciones f) es una fórmula equivalente a f sin<br />
-- signos de implicación. Por ejemplo,<br />
-- eliminaImplicaciones (p --> q)<br />
-- ==> (no p \/ q)<br />
-- eliminaImplicaciones (eliminaEquivalencias (p <--> q))<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- Nota: Se supone que f no tiene signos de equivalencia.<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaImplicaciones :: Prop -> Prop<br />
eliminaImplicaciones = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- interiorizaNegación :: Prop -> Prop<br />
-- tal que (interiorizaNegación f) es una fórmula equivalente a f donde<br />
-- las negaciones se aplican sólo a fórmulas atómicas. Por ejemplo,<br />
-- interiorizaNegación (no (no p)) ==> p<br />
-- interiorizaNegación (no (p /\ q)) ==> (no p \/ no q)<br />
-- interiorizaNegación (no (p \/ q)) ==> (no p /\ no q)<br />
-- interiorizaNegación (no (no (p \/ q))) ==> (p \/ q)<br />
-- interiorizaNegación (no ((no p) \/ q)) ==> (p /\ no q)<br />
-- Nota: Se supone que f no tiene equivalencias ni implicaciones. <br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaNegación :: Prop -> Prop<br />
interiorizaNegación = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- formaNormalNegativa :: Prop -> Prop<br />
-- tal que (formaNormalNegativa f) es una fórmula equivalente a f en<br />
-- forma normal negativa. Por ejemplo,<br />
-- formaNormalNegativa (p <--> q)<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- formaNormalNegativa ((p \/ (no q)) --> r)<br />
-- ==> ((no p /\ q) \/ r)<br />
-- formaNormalNegativa ((p /\ (q --> r)) --> s)<br />
-- ==> ((no p \/ (q /\ no r)) \/ s)<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalNegativa :: Prop -> Prop<br />
formaNormalNegativa f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
literal :: Prop -> Bool<br />
literal (Atom p) = True<br />
literal (Neg (Atom p)) = True<br />
literal _ = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir el tipo de dato Literal como sinónimo de<br />
-- fórmula. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Literal = Prop<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- complementario :: Literal -> Literal<br />
-- tal que (complementario l) es el complementario de l. Por ejemplo,<br />
-- complementario p ==> no p<br />
-- complementario (no p) ==> p<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
complementario :: Literal -> Literal<br />
complementario (Atom p) = Neg (Atom p)<br />
complementario (Neg (Atom p)) = Atom p<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- literalesFórmulaFNN :: Prop -> [Literal]<br />
-- tal que (literalesFórmulaFNN f) es el conjunto de los literales de la<br />
-- fórmula en forma normal negativa f.<br />
-- literalesFórmulaFNN (p \/ ((no q) \/ r)) ==> [p,no q,r]<br />
-- literalesFórmulaFNN p ==> [p]<br />
-- literalesFórmulaFNN (no p) ==> [no p]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
literalesFormulaFNN :: Prop -> [Literal]<br />
literalesFormulaFNN (Conj p q) = <br />
union (literalesFormulaFNN p) (literalesFormulaFNN q)<br />
literalesFormulaFNN (Disj p q) = <br />
union (literalesFormulaFNN p) (literalesFormulaFNN q)<br />
literalesFormulaFNN p = [p]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal conjuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- interiorizaDisyunción :: Prop -> Prop<br />
-- tal que (interiorizaDisyunción f) es una fórmula equivalente a f<br />
-- donde las disyunciones sólo se aplica a disyunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaDisyunción (p \/ (q /\ r)) ==> ((p \/ q) /\ (p \/ r))<br />
-- interiorizaDisyunción ((p /\ q) \/ r) ==> ((p \/ r) /\ (q \/ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
interiorizaDisyuncion :: Prop -> Prop<br />
interiorizaDisyuncion (Disj (Conj p q) r) = <br />
interiorizaDisyuncion <br />
(Conj (Disj (interiorizaDisyuncion p) (interiorizaDisyuncion r))<br />
(Disj (interiorizaDisyuncion q) (interiorizaDisyuncion r)))<br />
interiorizaDisyuncion (Disj r (Conj p q)) = <br />
interiorizaDisyuncion <br />
(Conj (Disj (interiorizaDisyuncion r) (interiorizaDisyuncion p))<br />
(Disj (interiorizaDisyuncion r) (interiorizaDisyuncion q)))<br />
interiorizaDisyuncion (Conj p q) = <br />
Conj (interiorizaDisyuncion p) (interiorizaDisyuncion q)<br />
interiorizaDisyuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- formaNormalConjuntiva :: Prop -> Prop<br />
-- tal que (formaNormalConjuntiva f) es una fórmula equivalente a f en<br />
-- forma normal conjuntiva. Por ejemplo,<br />
-- formaNormalConjuntiva (p /\ (q --> r))<br />
-- ==> (p /\ (no q \/ r))<br />
-- formaNormalConjuntiva (no (p /\ (q --> r)))<br />
-- ==> ((no p \/ q) /\ (no p \/ no r))<br />
-- formaNormalConjuntiva (no(p <--> r))<br />
-- ==> (((p \/ r) /\ (p \/ no p)) /\ ((no r \/ r) /\ (no r \/ no p)))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalConjuntiva :: Prop -> Prop<br />
formaNormalConjuntiva f = interiorizaDisyuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 11.2: validaPorFNC<br />
<br />
validaPorFNC:: Prop -> Bool<br />
validaPorFNC = undefined<br />
<br />
-- validaPorFNC ((p --> q) \/ (q --> p)) == True<br />
-- validaPorFNC ((p \/ q) /\ ((no q) \/ r)) == False<br />
-- validaPorFNC (p --> p) == True<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal disyuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- interiorizaConjunción :: Prop -> Prop<br />
-- tal que (interiorizaConjunción f) es una fórmula equivalente a f<br />
-- donde las conjunciones sólo se aplica a conjunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaConjunción (p /\ (q \/ r)) ==> ((p /\ q) \/ (p /\ r))<br />
-- interiorizaConjunción ((p \/ q) /\ r) ==> ((p /\ r) \/ (q /\ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
interiorizaConjuncion :: Prop -> Prop <br />
interiorizaConjuncion (Conj (Disj f g) h) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion h))<br />
(Conj (interiorizaConjuncion g) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Conj f (Disj g h)) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion g))<br />
(Conj (interiorizaConjuncion f) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Disj f g) =<br />
Disj (interiorizaConjuncion f) (interiorizaConjuncion g) <br />
interiorizaConjuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- formaNormalDisyuntiva :: Prop -> Prop<br />
-- tal que (formaNormalDisyuntiva f) es una fórmula equivalente a f en<br />
-- forma normal disyuntiva. Por ejemplo,<br />
-- formaNormalDisyuntiva (p /\ (q --> r))<br />
-- ==> ((p /\ no q) \/ (p /\ r))<br />
-- formaNormalDisyuntiva (no (p /\ (q --> r)))<br />
-- ==> (no p \/ (q /\ no r))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalDisyuntiva :: Prop -> Prop<br />
formaNormalDisyuntiva f = interiorizaConjuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 13.2: satisfaciblePorFND<br />
<br />
<br />
satisfaciblePorFND:: Prop -> Bool<br />
satisfaciblePorFND f = undefined<br />
<br />
<br />
-- satisfaciblePorFND ((p \/ q) /\ ((no q) \/ r)) == True<br />
-- satisfaciblePorFND (p /\ (no p)) == False<br />
-- satisfaciblePorFND ((p --> q) \/ (q --> p)) == True<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_9&diff=494
Relación 9
2013-05-14T15:37:39Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- FormasNormales.hs<br />
-- Formas normales.<br />
-- ---------------------------------------------------------------------<br />
<br />
module FormasNormales where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica <br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Equivalencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- esEquivalente :: Prop -> Prop -> Bool<br />
-- tal que (esEquivalente f g) se verifica si f y g son<br />
-- equivalentes. Por ejemplo,<br />
-- esEquivalente (p <--> q) ((p --> q) /\ (q --> p)) ==> True<br />
-- esEquivalente (p --> q) ((no p) \/ q) ==> True<br />
-- esEquivalente (p /\ q) (no ((no p) \/ (no q))) ==> True<br />
-- esEquivalente (p \/ q) (no ((no p) /\ (no q))) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esEquivalente :: Prop -> Prop -> Bool<br />
esEquivalente f g = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal negativa --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- eliminaEquivalencias :: Prop -> Prop<br />
-- tal que (eliminaEquivalencias f) es una fórmula equivalente a f sin<br />
-- signos de equivalencia. Por ejemplo,<br />
-- eliminaEquivalencias (p <--> q)<br />
-- ==> ((p --> q) /\ (q --> p))<br />
-- eliminaEquivalencias ((p <--> q) /\ (q <--> r))<br />
-- ==> (((p --> q) /\ (q --> p)) /\ ((q --> r) /\ (r --> q)))<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaEquivalencias :: Prop -> Prop<br />
eliminaEquivalencias = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- eliminaImplicaciones :: Prop -> Prop<br />
-- tal que (eliminaImplicaciones f) es una fórmula equivalente a f sin<br />
-- signos de implicación. Por ejemplo,<br />
-- eliminaImplicaciones (p --> q)<br />
-- ==> (no p \/ q)<br />
-- eliminaImplicaciones (eliminaEquivalencias (p <--> q))<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- Nota: Se supone que f no tiene signos de equivalencia.<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaImplicaciones :: Prop -> Prop<br />
eliminaImplicaciones = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- interiorizaNegación :: Prop -> Prop<br />
-- tal que (interiorizaNegación f) es una fórmula equivalente a f donde<br />
-- las negaciones se aplican sólo a fórmulas atómicas. Por ejemplo,<br />
-- interiorizaNegación (no (no p)) ==> p<br />
-- interiorizaNegación (no (p /\ q)) ==> (no p \/ no q)<br />
-- interiorizaNegación (no (p \/ q)) ==> (no p /\ no q)<br />
-- interiorizaNegación (no (no (p \/ q))) ==> (p \/ q)<br />
-- interiorizaNegación (no ((no p) \/ q)) ==> (p /\ no q)<br />
-- Nota: Se supone que f no tiene equivalencias ni implicaciones. <br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaNegación :: Prop -> Prop<br />
interiorizaNegación = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- formaNormalNegativa :: Prop -> Prop<br />
-- tal que (formaNormalNegativa f) es una fórmula equivalente a f en<br />
-- forma normal negativa. Por ejemplo,<br />
-- formaNormalNegativa (p <--> q)<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- formaNormalNegativa ((p \/ (no q)) --> r)<br />
-- ==> ((no p /\ q) \/ r)<br />
-- formaNormalNegativa ((p /\ (q --> r)) --> s)<br />
-- ==> ((no p \/ (q /\ no r)) \/ s)<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalNegativa :: Prop -> Prop<br />
formaNormalNegativa f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
literal :: Prop -> Bool<br />
literal = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir el tipo de dato Literal como sinónimo de<br />
-- fórmula. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Literal = Prop<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- complementario :: Literal -> Literal<br />
-- tal que (complementario l) es el complementario de l. Por ejemplo,<br />
-- complementario p ==> no p<br />
-- complementario (no p) ==> p<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
complementario :: Literal -> Literal<br />
complementario (Atom p) = Neg (Atom p)<br />
complementario (Neg (Atom p)) = Atom p<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- literalesFórmulaFNN :: Prop -> [Literal]<br />
-- tal que (literalesFórmulaFNN f) es el conjunto de los literales de la<br />
-- fórmula en forma normal negativa f.<br />
-- literalesFórmulaFNN (p \/ ((no q) \/ r)) ==> [p,no q,r]<br />
-- literalesFórmulaFNN p ==> [p]<br />
-- literalesFórmulaFNN (no p) ==> [no p]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
literalesFormulaFNN :: Prop -> [Literal]<br />
literalesFormulaFNN (Conj p q) = <br />
union (literalesFormulaFNN p) (literalesFormulaFNN q)<br />
literalesFormulaFNN (Disj p q) = <br />
union (literalesFormulaFNN p) (literalesFormulaFNN q)<br />
literalesFormulaFNN p = [p]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal conjuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- interiorizaDisyunción :: Prop -> Prop<br />
-- tal que (interiorizaDisyunción f) es una fórmula equivalente a f<br />
-- donde las disyunciones sólo se aplica a disyunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaDisyunción (p \/ (q /\ r)) ==> ((p \/ q) /\ (p \/ r))<br />
-- interiorizaDisyunción ((p /\ q) \/ r) ==> ((p \/ r) /\ (q \/ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
interiorizaDisyuncion :: Prop -> Prop<br />
interiorizaDisyuncion (Disj (Conj p q) r) = <br />
interiorizaDisyuncion <br />
(Conj (Disj (interiorizaDisyuncion p) (interiorizaDisyuncion r))<br />
(Disj (interiorizaDisyuncion q) (interiorizaDisyuncion r)))<br />
interiorizaDisyuncion (Disj r (Conj p q)) = <br />
interiorizaDisyuncion <br />
(Conj (Disj (interiorizaDisyuncion r) (interiorizaDisyuncion p))<br />
(Disj (interiorizaDisyuncion r) (interiorizaDisyuncion q)))<br />
interiorizaDisyuncion (Conj p q) = <br />
Conj (interiorizaDisyuncion p) (interiorizaDisyuncion q)<br />
interiorizaDisyuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- formaNormalConjuntiva :: Prop -> Prop<br />
-- tal que (formaNormalConjuntiva f) es una fórmula equivalente a f en<br />
-- forma normal conjuntiva. Por ejemplo,<br />
-- formaNormalConjuntiva (p /\ (q --> r))<br />
-- ==> (p /\ (no q \/ r))<br />
-- formaNormalConjuntiva (no (p /\ (q --> r)))<br />
-- ==> ((no p \/ q) /\ (no p \/ no r))<br />
-- formaNormalConjuntiva (no(p <--> r))<br />
-- ==> (((p \/ r) /\ (p \/ no p)) /\ ((no r \/ r) /\ (no r \/ no p)))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalConjuntiva :: Prop -> Prop<br />
formaNormalConjuntiva f = interiorizaDisyuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 11.2: validaPorFNC<br />
<br />
validaPorFNC:: Prop -> Bool<br />
validaPorFNC = undefined<br />
<br />
-- validaPorFNC ((p --> q) \/ (q --> p)) == True<br />
-- validaPorFNC ((p \/ q) /\ ((no q) \/ r)) == False<br />
-- validaPorFNC (p --> p) == True<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal disyuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- interiorizaConjunción :: Prop -> Prop<br />
-- tal que (interiorizaConjunción f) es una fórmula equivalente a f<br />
-- donde las conjunciones sólo se aplica a conjunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaConjunción (p /\ (q \/ r)) ==> ((p /\ q) \/ (p /\ r))<br />
-- interiorizaConjunción ((p \/ q) /\ r) ==> ((p /\ r) \/ (q /\ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
interiorizaConjuncion :: Prop -> Prop <br />
interiorizaConjuncion (Conj (Disj f g) h) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion h))<br />
(Conj (interiorizaConjuncion g) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Conj f (Disj g h)) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion g))<br />
(Conj (interiorizaConjuncion f) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Disj f g) =<br />
Disj (interiorizaConjuncion f) (interiorizaConjuncion g) <br />
interiorizaConjuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- formaNormalDisyuntiva :: Prop -> Prop<br />
-- tal que (formaNormalDisyuntiva f) es una fórmula equivalente a f en<br />
-- forma normal disyuntiva. Por ejemplo,<br />
-- formaNormalDisyuntiva (p /\ (q --> r))<br />
-- ==> ((p /\ no q) \/ (p /\ r))<br />
-- formaNormalDisyuntiva (no (p /\ (q --> r)))<br />
-- ==> (no p \/ (q /\ no r))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalDisyuntiva :: Prop -> Prop<br />
formaNormalDisyuntiva f = interiorizaConjuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 13.2: satisfaciblePorFND<br />
<br />
<br />
satisfaciblePorFND:: Prop -> Bool<br />
satisfaciblePorFND f = undefined<br />
<br />
<br />
-- satisfaciblePorFND ((p \/ q) /\ ((no q) \/ r)) == True<br />
-- satisfaciblePorFND (p /\ (no p)) == False<br />
-- satisfaciblePorFND ((p --> q) \/ (q --> p)) == True<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_9&diff=475
Relación 9
2013-05-05T09:17:31Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- FormasNormales.hs<br />
-- Formas normales.<br />
-- ---------------------------------------------------------------------<br />
<br />
module FormasNormales where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica <br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Equivalencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- esEquivalente :: Prop -> Prop -> Bool<br />
-- tal que (esEquivalente f g) se verifica si f y g son<br />
-- equivalentes. Por ejemplo,<br />
-- esEquivalente (p <--> q) ((p --> q) /\ (q --> p)) ==> True<br />
-- esEquivalente (p --> q) ((no p) \/ q) ==> True<br />
-- esEquivalente (p /\ q) (no ((no p) \/ (no q))) ==> True<br />
-- esEquivalente (p \/ q) (no ((no p) /\ (no q))) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esEquivalente :: Prop -> Prop -> Bool<br />
esEquivalente f g = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal negativa --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- eliminaEquivalencias :: Prop -> Prop<br />
-- tal que (eliminaEquivalencias f) es una fórmula equivalente a f sin<br />
-- signos de equivalencia. Por ejemplo,<br />
-- eliminaEquivalencias (p <--> q)<br />
-- ==> ((p --> q) /\ (q --> p))<br />
-- eliminaEquivalencias ((p <--> q) /\ (q <--> r))<br />
-- ==> (((p --> q) /\ (q --> p)) /\ ((q --> r) /\ (r --> q)))<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaEquivalencias :: Prop -> Prop<br />
eliminaEquivalencias = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- eliminaImplicaciones :: Prop -> Prop<br />
-- tal que (eliminaImplicaciones f) es una fórmula equivalente a f sin<br />
-- signos de implicación. Por ejemplo,<br />
-- eliminaImplicaciones (p --> q)<br />
-- ==> (no p \/ q)<br />
-- eliminaImplicaciones (eliminaEquivalencias (p <--> q))<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- Nota: Se supone que f no tiene signos de equivalencia.<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaImplicaciones :: Prop -> Prop<br />
eliminaImplicaciones = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- interiorizaNegación :: Prop -> Prop<br />
-- tal que (interiorizaNegación f) es una fórmula equivalente a f donde<br />
-- las negaciones se aplican sólo a fórmulas atómicas. Por ejemplo,<br />
-- interiorizaNegación (no (no p)) ==> p<br />
-- interiorizaNegación (no (p /\ q)) ==> (no p \/ no q)<br />
-- interiorizaNegación (no (p \/ q)) ==> (no p /\ no q)<br />
-- interiorizaNegación (no (no (p \/ q))) ==> (p \/ q)<br />
-- interiorizaNegación (no ((no p) \/ q)) ==> (p /\ no q)<br />
-- Nota: Se supone que f no tiene equivalencias ni implicaciones. <br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaNegación :: Prop -> Prop<br />
interiorizaNegación = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- formaNormalNegativa :: Prop -> Prop<br />
-- tal que (formaNormalNegativa f) es una fórmula equivalente a f en<br />
-- forma normal negativa. Por ejemplo,<br />
-- formaNormalNegativa (p <--> q)<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- formaNormalNegativa ((p \/ (no q)) --> r)<br />
-- ==> ((no p /\ q) \/ r)<br />
-- formaNormalNegativa ((p /\ (q --> r)) --> s)<br />
-- ==> ((no p \/ (q /\ no r)) \/ s)<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalNegativa :: Prop -> Prop<br />
formaNormalNegativa f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
literal :: Prop -> Bool<br />
literal = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir el tipo de dato Literal como sinónimo de<br />
-- fórmula. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Literal = Prop<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- complementario :: Literal -> Literal<br />
-- tal que (complementario l) es el complementario de l. Por ejemplo,<br />
-- complementario p ==> no p<br />
-- complementario (no p) ==> p<br />
-- ---------------------------------------------------------------------<br />
<br />
complementario :: Literal -> Literal<br />
complementario = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- literalesFórmulaFNN :: Prop -> [Literal]<br />
-- tal que (literalesFórmulaFNN f) es el conjunto de los literales de la<br />
-- fórmula en forma normal negativa f.<br />
-- literalesFórmulaFNN (p \/ ((no q) \/ r)) ==> [p,no q,r]<br />
-- literalesFórmulaFNN p ==> [p]<br />
-- literalesFórmulaFNN (no p) ==> [no p]<br />
-- ---------------------------------------------------------------------<br />
<br />
literalesFórmulaFNN :: Prop -> [Literal]<br />
literalesFórmulaFNN = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal conjuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- interiorizaDisyunción :: Prop -> Prop<br />
-- tal que (interiorizaDisyunción f) es una fórmula equivalente a f<br />
-- donde las disyunciones sólo se aplica a disyunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaDisyunción (p \/ (q /\ r)) ==> ((p \/ q) /\ (p \/ r))<br />
-- interiorizaDisyunción ((p /\ q) \/ r) ==> ((p \/ r) /\ (q \/ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaDisyunción :: Prop -> Prop<br />
interiorizaDisyunción = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- formaNormalConjuntiva :: Prop -> Prop<br />
-- tal que (formaNormalConjuntiva f) es una fórmula equivalente a f en<br />
-- forma normal conjuntiva. Por ejemplo,<br />
-- formaNormalConjuntiva (p /\ (q --> r))<br />
-- ==> (p /\ (no q \/ r))<br />
-- formaNormalConjuntiva (no (p /\ (q --> r)))<br />
-- ==> ((no p \/ q) /\ (no p \/ no r))<br />
-- formaNormalConjuntiva (no(p <--> r))<br />
-- ==> (((p \/ r) /\ (p \/ no p)) /\ ((no r \/ r) /\ (no r \/ no p)))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalConjuntiva :: Prop -> Prop<br />
formaNormalConjuntiva f = interiorizaDisyuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 11.2: validaPorFNC<br />
<br />
validaPorFNC:: Prop -> Bool<br />
validaPorFNC = undefined<br />
<br />
-- validaPorFNC ((p --> q) \/ (q --> p)) == True<br />
-- validaPorFNC ((p \/ q) /\ ((no q) \/ r)) == False<br />
-- validaPorFNC (p --> p) == True<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal disyuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- interiorizaConjunción :: Prop -> Prop<br />
-- tal que (interiorizaConjunción f) es una fórmula equivalente a f<br />
-- donde las conjunciones sólo se aplica a conjunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaConjunción (p /\ (q \/ r)) ==> ((p /\ q) \/ (p /\ r))<br />
-- interiorizaConjunción ((p \/ q) /\ r) ==> ((p /\ r) \/ (q /\ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
interiorizaConjuncion :: Prop -> Prop <br />
interiorizaConjuncion (Conj (Disj f g) h) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion h))<br />
(Conj (interiorizaConjuncion g) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Conj f (Disj g h)) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion g))<br />
(Conj (interiorizaConjuncion f) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Disj f g) =<br />
Disj (interiorizaConjuncion f) (interiorizaConjuncion g) <br />
interiorizaConjuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- formaNormalDisyuntiva :: Prop -> Prop<br />
-- tal que (formaNormalDisyuntiva f) es una fórmula equivalente a f en<br />
-- forma normal disyuntiva. Por ejemplo,<br />
-- formaNormalDisyuntiva (p /\ (q --> r))<br />
-- ==> ((p /\ no q) \/ (p /\ r))<br />
-- formaNormalDisyuntiva (no (p /\ (q --> r)))<br />
-- ==> (no p \/ (q /\ no r))<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
<br />
formaNormalDisyuntiva :: Prop -> Prop<br />
formaNormalDisyuntiva f = interiorizaConjuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 13.2: satisfaciblePorFND<br />
<br />
<br />
satisfaciblePorFND:: Prop -> Bool<br />
satisfaciblePorFND f = undefined<br />
<br />
<br />
-- satisfaciblePorFND ((p \/ q) /\ ((no q) \/ r)) == True<br />
-- satisfaciblePorFND (p /\ (no p)) == False<br />
-- satisfaciblePorFND ((p --> q) \/ (q --> p)) == True<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_9&diff=474
Relación 9
2013-05-05T09:16:44Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- FormasNormales.hs<br />
-- Formas normales.<br />
-- ---------------------------------------------------------------------<br />
<br />
module FormasNormales where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica <br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Equivalencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- esEquivalente :: Prop -> Prop -> Bool<br />
-- tal que (esEquivalente f g) se verifica si f y g son<br />
-- equivalentes. Por ejemplo,<br />
-- esEquivalente (p <--> q) ((p --> q) /\ (q --> p)) ==> True<br />
-- esEquivalente (p --> q) ((no p) \/ q) ==> True<br />
-- esEquivalente (p /\ q) (no ((no p) \/ (no q))) ==> True<br />
-- esEquivalente (p \/ q) (no ((no p) /\ (no q))) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esEquivalente :: Prop -> Prop -> Bool<br />
esEquivalente f g = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal negativa --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- eliminaEquivalencias :: Prop -> Prop<br />
-- tal que (eliminaEquivalencias f) es una fórmula equivalente a f sin<br />
-- signos de equivalencia. Por ejemplo,<br />
-- eliminaEquivalencias (p <--> q)<br />
-- ==> ((p --> q) /\ (q --> p))<br />
-- eliminaEquivalencias ((p <--> q) /\ (q <--> r))<br />
-- ==> (((p --> q) /\ (q --> p)) /\ ((q --> r) /\ (r --> q)))<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaEquivalencias :: Prop -> Prop<br />
eliminaEquivalencias = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- eliminaImplicaciones :: Prop -> Prop<br />
-- tal que (eliminaImplicaciones f) es una fórmula equivalente a f sin<br />
-- signos de implicación. Por ejemplo,<br />
-- eliminaImplicaciones (p --> q)<br />
-- ==> (no p \/ q)<br />
-- eliminaImplicaciones (eliminaEquivalencias (p <--> q))<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- Nota: Se supone que f no tiene signos de equivalencia.<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaImplicaciones :: Prop -> Prop<br />
eliminaImplicaciones = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- interiorizaNegación :: Prop -> Prop<br />
-- tal que (interiorizaNegación f) es una fórmula equivalente a f donde<br />
-- las negaciones se aplican sólo a fórmulas atómicas. Por ejemplo,<br />
-- interiorizaNegación (no (no p)) ==> p<br />
-- interiorizaNegación (no (p /\ q)) ==> (no p \/ no q)<br />
-- interiorizaNegación (no (p \/ q)) ==> (no p /\ no q)<br />
-- interiorizaNegación (no (no (p \/ q))) ==> (p \/ q)<br />
-- interiorizaNegación (no ((no p) \/ q)) ==> (p /\ no q)<br />
-- Nota: Se supone que f no tiene equivalencias ni implicaciones. <br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaNegación :: Prop -> Prop<br />
interiorizaNegación = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- formaNormalNegativa :: Prop -> Prop<br />
-- tal que (formaNormalNegativa f) es una fórmula equivalente a f en<br />
-- forma normal negativa. Por ejemplo,<br />
-- formaNormalNegativa (p <--> q)<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- formaNormalNegativa ((p \/ (no q)) --> r)<br />
-- ==> ((no p /\ q) \/ r)<br />
-- formaNormalNegativa ((p /\ (q --> r)) --> s)<br />
-- ==> ((no p \/ (q /\ no r)) \/ s)<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalNegativa :: Prop -> Prop<br />
formaNormalNegativa f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
literal :: Prop -> Bool<br />
literal = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir el tipo de dato Literal como sinónimo de<br />
-- fórmula. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Literal = Prop<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- complementario :: Literal -> Literal<br />
-- tal que (complementario l) es el complementario de l. Por ejemplo,<br />
-- complementario p ==> no p<br />
-- complementario (no p) ==> p<br />
-- ---------------------------------------------------------------------<br />
<br />
complementario :: Literal -> Literal<br />
complementario = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- literalesFórmulaFNN :: Prop -> [Literal]<br />
-- tal que (literalesFórmulaFNN f) es el conjunto de los literales de la<br />
-- fórmula en forma normal negativa f.<br />
-- literalesFórmulaFNN (p \/ ((no q) \/ r)) ==> [p,no q,r]<br />
-- literalesFórmulaFNN p ==> [p]<br />
-- literalesFórmulaFNN (no p) ==> [no p]<br />
-- ---------------------------------------------------------------------<br />
<br />
literalesFórmulaFNN :: Prop -> [Literal]<br />
literalesFórmulaFNN = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal conjuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- interiorizaDisyunción :: Prop -> Prop<br />
-- tal que (interiorizaDisyunción f) es una fórmula equivalente a f<br />
-- donde las disyunciones sólo se aplica a disyunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaDisyunción (p \/ (q /\ r)) ==> ((p \/ q) /\ (p \/ r))<br />
-- interiorizaDisyunción ((p /\ q) \/ r) ==> ((p \/ r) /\ (q \/ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaDisyunción :: Prop -> Prop<br />
interiorizaDisyunción = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- formaNormalConjuntiva :: Prop -> Prop<br />
-- tal que (formaNormalConjuntiva f) es una fórmula equivalente a f en<br />
-- forma normal conjuntiva. Por ejemplo,<br />
-- formaNormalConjuntiva (p /\ (q --> r))<br />
-- ==> (p /\ (no q \/ r))<br />
-- formaNormalConjuntiva (no (p /\ (q --> r)))<br />
-- ==> ((no p \/ q) /\ (no p \/ no r))<br />
-- formaNormalConjuntiva (no(p <--> r))<br />
-- ==> (((p \/ r) /\ (p \/ no p)) /\ ((no r \/ r) /\ (no r \/ no p)))<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalConjuntiva :: Prop -> Prop<br />
formaNormalConjuntiva f = interiorizaDisyuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 11.2: validaPorFNC<br />
<br />
validaPorFNC:: Prop -> Bool<br />
validaPorFNC = undefined<br />
<br />
-- validaPorFNC ((p --> q) \/ (q --> p)) == True<br />
-- validaPorFNC ((p \/ q) /\ ((no q) \/ r)) == False<br />
-- validaPorFNC (p --> p) == True<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal disyuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- interiorizaConjunción :: Prop -> Prop<br />
-- tal que (interiorizaConjunción f) es una fórmula equivalente a f<br />
-- donde las conjunciones sólo se aplica a conjunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaConjunción (p /\ (q \/ r)) ==> ((p /\ q) \/ (p /\ r))<br />
-- interiorizaConjunción ((p \/ q) /\ r) ==> ((p /\ r) \/ (q /\ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
<br />
interiorizaConjuncion :: Prop -> Prop <br />
interiorizaConjuncion (Conj (Disj f g) h) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion h))<br />
(Conj (interiorizaConjuncion g) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Conj f (Disj g h)) =<br />
interiorizaConjuncion (Disj (Conj (interiorizaConjuncion f) (interiorizaConjuncion g))<br />
(Conj (interiorizaConjuncion f) (interiorizaConjuncion h))) <br />
interiorizaConjuncion (Disj f g) =<br />
Disj (interiorizaConjuncion f) (interiorizaConjuncion g) <br />
interiorizaConjuncion f = f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- formaNormalDisyuntiva :: Prop -> Prop<br />
-- tal que (formaNormalDisyuntiva f) es una fórmula equivalente a f en<br />
-- forma normal disyuntiva. Por ejemplo,<br />
-- formaNormalDisyuntiva (p /\ (q --> r))<br />
-- ==> ((p /\ no q) \/ (p /\ r))<br />
-- formaNormalDisyuntiva (no (p /\ (q --> r)))<br />
-- ==> (no p \/ (q /\ no r))<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalDisyuntiva :: Prop -> Prop<br />
formaNormalDisyuntiva f = interiorizaConjuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 13.2: satisfaciblePorFND<br />
<br />
<br />
satisfaciblePorFND:: Prop -> Bool<br />
satisfaciblePorFND f = undefined<br />
<br />
<br />
-- satisfaciblePorFND ((p \/ q) /\ ((no q) \/ r)) == True<br />
-- satisfaciblePorFND (p /\ (no p)) == False<br />
-- satisfaciblePorFND ((p --> q) \/ (q --> p)) == True<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_9&diff=473
Relación 9
2013-05-05T09:12:25Z
<p>Isaduatos: </p>
<hr />
<div><source lang = "haskell"><br />
-- FormasNormales.hs<br />
-- Formas normales.<br />
-- ---------------------------------------------------------------------<br />
<br />
module FormasNormales where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librería suxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica <br />
import Data.List<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Equivalencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- esEquivalente :: Prop -> Prop -> Bool<br />
-- tal que (esEquivalente f g) se verifica si f y g son<br />
-- equivalentes. Por ejemplo,<br />
-- esEquivalente (p <--> q) ((p --> q) /\ (q --> p)) ==> True<br />
-- esEquivalente (p --> q) ((no p) \/ q) ==> True<br />
-- esEquivalente (p /\ q) (no ((no p) \/ (no q))) ==> True<br />
-- esEquivalente (p \/ q) (no ((no p) /\ (no q))) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esEquivalente :: Prop -> Prop -> Bool<br />
esEquivalente f g = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal negativa --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- eliminaEquivalencias :: Prop -> Prop<br />
-- tal que (eliminaEquivalencias f) es una fórmula equivalente a f sin<br />
-- signos de equivalencia. Por ejemplo,<br />
-- eliminaEquivalencias (p <--> q)<br />
-- ==> ((p --> q) /\ (q --> p))<br />
-- eliminaEquivalencias ((p <--> q) /\ (q <--> r))<br />
-- ==> (((p --> q) /\ (q --> p)) /\ ((q --> r) /\ (r --> q)))<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaEquivalencias :: Prop -> Prop<br />
eliminaEquivalencias = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- eliminaImplicaciones :: Prop -> Prop<br />
-- tal que (eliminaImplicaciones f) es una fórmula equivalente a f sin<br />
-- signos de implicación. Por ejemplo,<br />
-- eliminaImplicaciones (p --> q)<br />
-- ==> (no p \/ q)<br />
-- eliminaImplicaciones (eliminaEquivalencias (p <--> q))<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- Nota: Se supone que f no tiene signos de equivalencia.<br />
-- ---------------------------------------------------------------------<br />
<br />
eliminaImplicaciones :: Prop -> Prop<br />
eliminaImplicaciones = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- interiorizaNegación :: Prop -> Prop<br />
-- tal que (interiorizaNegación f) es una fórmula equivalente a f donde<br />
-- las negaciones se aplican sólo a fórmulas atómicas. Por ejemplo,<br />
-- interiorizaNegación (no (no p)) ==> p<br />
-- interiorizaNegación (no (p /\ q)) ==> (no p \/ no q)<br />
-- interiorizaNegación (no (p \/ q)) ==> (no p /\ no q)<br />
-- interiorizaNegación (no (no (p \/ q))) ==> (p \/ q)<br />
-- interiorizaNegación (no ((no p) \/ q)) ==> (p /\ no q)<br />
-- Nota: Se supone que f no tiene equivalencias ni implicaciones. <br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaNegación :: Prop -> Prop<br />
interiorizaNegación = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- formaNormalNegativa :: Prop -> Prop<br />
-- tal que (formaNormalNegativa f) es una fórmula equivalente a f en<br />
-- forma normal negativa. Por ejemplo,<br />
-- formaNormalNegativa (p <--> q)<br />
-- ==> ((no p \/ q) /\ (no q \/ p))<br />
-- formaNormalNegativa ((p \/ (no q)) --> r)<br />
-- ==> ((no p /\ q) \/ r)<br />
-- formaNormalNegativa ((p /\ (q --> r)) --> s)<br />
-- ==> ((no p \/ (q /\ no r)) \/ s)<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalNegativa :: Prop -> Prop<br />
formaNormalNegativa f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
literal :: Prop -> Bool<br />
literal = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir el tipo de dato Literal como sinónimo de<br />
-- fórmula. <br />
-- ---------------------------------------------------------------------<br />
<br />
type Literal = Prop<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- complementario :: Literal -> Literal<br />
-- tal que (complementario l) es el complementario de l. Por ejemplo,<br />
-- complementario p ==> no p<br />
-- complementario (no p) ==> p<br />
-- ---------------------------------------------------------------------<br />
<br />
complementario :: Literal -> Literal<br />
complementario = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- literalesFórmulaFNN :: Prop -> [Literal]<br />
-- tal que (literalesFórmulaFNN f) es el conjunto de los literales de la<br />
-- fórmula en forma normal negativa f.<br />
-- literalesFórmulaFNN (p \/ ((no q) \/ r)) ==> [p,no q,r]<br />
-- literalesFórmulaFNN p ==> [p]<br />
-- literalesFórmulaFNN (no p) ==> [no p]<br />
-- ---------------------------------------------------------------------<br />
<br />
literalesFórmulaFNN :: Prop -> [Literal]<br />
literalesFórmulaFNN = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal conjuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- interiorizaDisyunción :: Prop -> Prop<br />
-- tal que (interiorizaDisyunción f) es una fórmula equivalente a f<br />
-- donde las disyunciones sólo se aplica a disyunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaDisyunción (p \/ (q /\ r)) ==> ((p \/ q) /\ (p \/ r))<br />
-- interiorizaDisyunción ((p /\ q) \/ r) ==> ((p \/ r) /\ (q \/ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaDisyunción :: Prop -> Prop<br />
interiorizaDisyunción = undefined <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- formaNormalConjuntiva :: Prop -> Prop<br />
-- tal que (formaNormalConjuntiva f) es una fórmula equivalente a f en<br />
-- forma normal conjuntiva. Por ejemplo,<br />
-- formaNormalConjuntiva (p /\ (q --> r))<br />
-- ==> (p /\ (no q \/ r))<br />
-- formaNormalConjuntiva (no (p /\ (q --> r)))<br />
-- ==> ((no p \/ q) /\ (no p \/ no r))<br />
-- formaNormalConjuntiva (no(p <--> r))<br />
-- ==> (((p \/ r) /\ (p \/ no p)) /\ ((no r \/ r) /\ (no r \/ no p)))<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalConjuntiva :: Prop -> Prop<br />
formaNormalConjuntiva f = interiorizaDisyuncion (formaNormalNegativa f)<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 11.2: validaPorFNC<br />
<br />
validaPorFNC:: Prop -> Bool<br />
validaPorFNC = undefined<br />
<br />
-- validaPorFNC ((p --> q) \/ (q --> p)) == True<br />
-- validaPorFNC ((p \/ q) /\ ((no q) \/ r)) == False<br />
-- validaPorFNC (p --> p) == True<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Transformación a forma normal disyuntiva --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- interiorizaConjunción :: Prop -> Prop<br />
-- tal que (interiorizaConjunción f) es una fórmula equivalente a f<br />
-- donde las conjunciones sólo se aplica a conjunciones o literales. Por<br />
-- ejemplo, <br />
-- interiorizaConjunción (p /\ (q \/ r)) ==> ((p /\ q) \/ (p /\ r))<br />
-- interiorizaConjunción ((p \/ q) /\ r) ==> ((p /\ r) \/ (q /\ r))<br />
-- Nota: Se supone que f está en forma normal negativa.<br />
-- ---------------------------------------------------------------------<br />
<br />
interiorizaConjunción :: Prop -> Prop<br />
interiorizaConjunción = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- formaNormalDisyuntiva :: Prop -> Prop<br />
-- tal que (formaNormalDisyuntiva f) es una fórmula equivalente a f en<br />
-- forma normal disyuntiva. Por ejemplo,<br />
-- formaNormalDisyuntiva (p /\ (q --> r))<br />
-- ==> ((p /\ no q) \/ (p /\ r))<br />
-- formaNormalDisyuntiva (no (p /\ (q --> r)))<br />
-- ==> (no p \/ (q /\ no r))<br />
-- ---------------------------------------------------------------------<br />
<br />
formaNormalDisyuntiva :: Prop -> Prop<br />
formaNormalDisyuntiva f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Ejercicio 13.2: satisfaciblePorFND<br />
<br />
<br />
satisfaciblePorFND:: Prop -> Bool<br />
satisfaciblePorFND f = undefined<br />
<br />
<br />
-- satisfaciblePorFND ((p \/ q) /\ ((no q) \/ r)) == True<br />
-- satisfaciblePorFND (p /\ (no p)) == False<br />
-- satisfaciblePorFND ((p --> q) \/ (q --> p)) == True<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Ejercicio_3&diff=453
Ejercicio 3
2013-04-26T14:03:33Z
<p>Isaduatos: /* Selección del ejercicio */</p>
<hr />
<div>== Enunciado ==<br />
El tercer ejercicio evaluable consiste en la realización de un ejercicio de argumentación en lógica de primer orden, haciendo la demostración por deducción natural con Isabelle/HOL y por tableros semánticos.<br />
Para ello, <br />
* Cada alumno elegirá uno de los ejercicios propuestos en [[E3|E3]].<br />
* Una vez elegido, lo anotará en la lista que se muestra a continuación, no pudiendo un mismo ejercicio ser elegido por más de un alumno. <br />
* Se enviará a mjoseh@us.es antes del viernes 10 de mayo de 2013, dos ficheros: uno usuario_3a.thy con la prueba por deducción natural y otro con la prueba por tableros.<br />
* Los lemas que se usen en una demostración tendrán que ser probados de forma no automática.<br />
* En la valoración del ejercicio se tendrá en cuenta tanto el nivel de dificultad como la calidad de la demostración.<br />
<br />
<br />
== Selección del ejercicio ==<br />
<br />
<br />
* Ejercicio 1: <br />
* Ejercicio 2: Francisco Vilches Chacón<br />
* Ejercicio 3: <br />
* Ejercicio 4: <br />
* Ejercicio 5: <br />
* Ejercicio 6: <br />
* Ejercicio 7: <br />
* Ejercicio 8: <br />
* Ejercicio 9: <br />
* Ejercicio 10: <br />
* Ejercicio 11: <br />
* Ejercicio 12: <br />
* Ejercicio 13: <br />
* Ejercicio 14: Carmen Martínez Navarro <br />
* Ejercicio 15: <br />
* Ejercicio 16: <br />
* Ejercicio 17: <br />
* Ejercicio 18: <br />
* Ejercicio 19: <br />
* Ejercicio 20: <br />
* Ejercicio 21: <br />
* Ejercicio 22: <br />
* Ejercicio 23: <br />
* Ejercicio 24: <br />
* Ejercicio 25: <br />
* Ejercicio 26: José María Contreras Beltrán<br />
* Ejercicio 27: Isabel Duarte Tosso<br />
* Ejercicio 28:</div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_8&diff=449
Relación 8
2013-04-26T09:57:12Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
<br />
-- TablerosSemánticos.hs<br />
-- Tableros semánticos proposicionales.<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module TablerosSemanticos where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 0: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- "Pedro Ros"<br />
literal :: Prop -> Bool<br />
literal (Atom p) = True<br />
literal (Neg (Atom p)) = True<br />
literal x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Notación uniforme --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- dobleNegación :: Prop -> Bool<br />
-- tal que (dobleNegación f) se verifica si f es una doble negación. Por<br />
-- ejemplo, <br />
-- dobleNegación (no (no p)) ==> True<br />
-- dobleNegación (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
dobleNegacion :: Prop -> Bool<br />
dobleNegacion (Neg (Neg p))= True<br />
dobleNegacion x = False<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- alfa :: Prop -> Bool<br />
-- tal que (alfa f) se verifica si f es una fórmula alfa.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
alfa :: Prop -> Bool<br />
alfa (Conj p q) = True<br />
alfa (Neg (Impl p q))= True<br />
alfa (Neg (Disj p q))= True<br />
alfa (Equi p q) = True<br />
alfa x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- beta :: Prop -> Bool<br />
-- tal que (beta d) se verifica si f es una fórmula beta.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
beta :: Prop -> Bool<br />
beta (Disj p q) = True<br />
beta (Impl p q) = True<br />
beta (Neg (Conj p q)) = True<br />
beta (Neg (Equi p q))= True<br />
beta p = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- componentes :: Prop -> [Prop]<br />
-- tal que (componentes ) es la lista de las componentes de la fórmula<br />
-- f. Por ejemplo, <br />
-- componentes (p /\ q --> r) ==> [no (p /\ q),r]<br />
-- componentes (no (p /\ q --> r)) ==> [(p /\ q),no r]<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
componentes :: Prop -> [Prop]<br />
componentes (Conj p q) = [p,q]<br />
componentes (Neg(Impl p q)) = [p,no q]<br />
componentes (Neg(Disj p q))= [no p, no q]<br />
componentes (Equi p q) = [Impl p q, Impl q p]<br />
componentes (Disj p q) = [p, q]<br />
componentes (Impl p q) = [no p, q]<br />
componentes (Neg(Conj p q))= [no p, no q]<br />
componentes (Neg(Equi p q))=[Neg(Impl p q), Neg(Impl q p)]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos mediante tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- conjuntoDeLiterales :: [Prop] -> Bool<br />
-- tal que (conjuntoDeLiterales fs) se verifica si fs es un conjunto de<br />
-- literales. Por ejemplo, <br />
-- conjuntoDeLiterales [p --> q, no r, r /\ s, p] ==> False<br />
-- conjuntoDeLiterales [p, no q, r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
conjuntoDeLiterales :: [Prop] -> Bool<br />
conjuntoDeLiterales []= True<br />
conjuntoDeLiterales (x:xs)= if literal x then conjuntoDeLiterales xs<br />
else False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- tieneContradicción :: [Prop] -> Bool<br />
-- tal que (tieneContradicción fs) se verifica si fs contiene una<br />
-- fórmula y su negación. Por ejemplo,<br />
-- tieneContradicción [r, p /\ q, s, no(p /\ q)] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
tieneContradiccion :: [Prop] -> Bool<br />
tieneContradiccion [f] = False<br />
tieneContradiccion ((Neg f):fs) = if elem f fs then True else<br />
tieneContradiccion fs<br />
tieneContradiccion (f:fs)= if elem (no f) fs then True else<br />
tieneContradiccion fs<br />
<br />
<br />
<br />
-- Isabel Duarte<br />
tieneContradiccion2 :: [Prop] -> Bool<br />
tieneContradiccion2 fs = or [elem (no x) fs | x <- fs]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónDN fs f) es la expansión de fs mediante la doble<br />
-- negación f. Por ejemplo,<br />
-- expansiónDN [p, no(no q), r] (no(no q)) ==> [[q,p,r]]<br />
-- ---------------------------------------------------------------------<br />
--José María Contreras<br />
elim (Neg(Neg f)) = f <br />
<br />
<br />
expansionDN :: [Prop] -> Prop -> [[Prop]]<br />
expansionDN fs f = [(elim f):[x|x<-fs,x/=f]]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónAlfa fs f) es la expansión de fs mediante la<br />
-- fórmula alfa f. Por ejemplo,<br />
-- expansiónAlfa [q, (p1 /\ p2) , r] (p1 /\ p2) ==> [[p1,p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
--José María Contreras<br />
<br />
expansionAlfa :: [Prop] -> Prop -> [[Prop]]<br />
expansionAlfa fs f = [(componentes f)`union`(delete f fs)]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónBeta fs f) es la expansión de fs mediante la<br />
-- fórmula beta f. Por ejemplo,<br />
-- expansiónBeta [q, (p1 \/ p2) , r] (p1 \/ p2) ==> [[p1,q,r],[p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
--José María Contreras<br />
<br />
expansionBeta :: [Prop] -> Prop -> [[Prop]]<br />
expansionBeta fs f = [x:(delete f fs)| x<-(componentes f)]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- sucesores :: [Prop] -> [[Prop]]<br />
-- tal que (sucesores fs) es la lista de sucesores de fs. Por ejemplo,<br />
-- sucesores [q \/ s, no(no r), p1 /\ p2] => [[r,(q \/ s),(p1 /\ p2)]]<br />
-- sucesores [r,(q \/ s),(p1 /\ p2)] => [[p1,p2,r,(q \/ s)]]<br />
-- sucesores [p1,p2,r,(q \/ s)] => [[q,p1,p2,r],[s,p1,p2,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
sucesores :: [Prop] -> [[Prop]]<br />
sucesores fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosTab :: [Prop] -> [[Prop]]<br />
-- tal que (modelosTab fs) es el conjunto de los modelos de fs<br />
-- calculados mediante el método de tableros semánticos. Por ejemplo,<br />
-- modelosTab [p --> q, no(q --> p)] <br />
-- ==> [[no p,q],[q,no p]]<br />
-- modelosTab [p --> q, no q --> no p] <br />
-- ==> [[q,no p],[no p],[q],[no p,q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosTab :: [Prop] -> [[Prop]]<br />
modelosTab fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- subconjunto :: Eq a => [a] -> [a] -> Bool<br />
-- tal que (subconjunto x y) se verifica si x es subconjunto de y. Por<br />
-- ejemplo, <br />
-- subconjunto [1,3] [3,2,1] ==> True<br />
-- subconjunto [1,3,5] [3,2,1] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Isabel Duarte<br />
subconjunto :: Eq a => [a] -> [a] -> Bool<br />
subconjunto xs ys = and [elem x ys | x <- xs]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- modelosGenerales :: [Prop] -> [[Prop]]<br />
-- tal que (modelosGenerales fs) es el conjunto de los modelos generales<br />
-- de fs calculados mediante el método de tableros semánticos. Por<br />
-- ejemplo, <br />
-- modelosGenerales [p --> q, no q --> no p] ==> [[no p],[q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosGenerales :: [Prop] -> [[Prop]]<br />
modelosGenerales fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Teoremas por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esTeoremaPorTableros :: Prop -> Bool<br />
-- tal que (esTeoremaPorTableros f) se verifica si la fórmula f es<br />
-- teorema (mediante tableros semánticos). Por ejemplo, <br />
-- esTeoremaPorTableros (p --> p) ==> True<br />
-- esTeoremaPorTableros (p --> q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esTeoremaPorTableros :: Prop -> Bool<br />
esTeoremaPorTableros f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
-- tal que (esDeduciblePorTableros fs f) se verifica si la fórmula f es<br />
-- consecuencia (mediante tableros) del conjunto de fórmulas fs. Por<br />
-- ejemplo,<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p --> r) ==> True<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p <--> r) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
esDeduciblePorTableros fs f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_8&diff=434
Relación 8
2013-04-24T11:13:09Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
<br />
-- TablerosSemánticos.hs<br />
-- Tableros semánticos proposicionales.<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module TablerosSemanticos where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 0: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- "Pedro Ros"<br />
literal :: Prop -> Bool<br />
literal (Atom p) = True<br />
literal (Neg (Atom p)) = True<br />
literal x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Notación uniforme --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- dobleNegación :: Prop -> Bool<br />
-- tal que (dobleNegación f) se verifica si f es una doble negación. Por<br />
-- ejemplo, <br />
-- dobleNegación (no (no p)) ==> True<br />
-- dobleNegación (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
dobleNegacion :: Prop -> Bool<br />
dobleNegacion (Neg (Neg p))= True<br />
dobleNegacion x = False<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- alfa :: Prop -> Bool<br />
-- tal que (alfa f) se verifica si f es una fórmula alfa.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
alfa :: Prop -> Bool<br />
alfa (Conj p q) = True<br />
alfa (Neg (Impl p q))= True<br />
alfa (Neg (Disj p q))= True<br />
alfa (Equi p q) = True<br />
alfa x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- beta :: Prop -> Bool<br />
-- tal que (beta d) se verifica si f es una fórmula beta.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
beta :: Prop -> Bool<br />
beta (Disj p q) = True<br />
beta (Impl p q) = True<br />
beta (Neg (Conj p q)) = True<br />
beta (Neg (Equi p q))= True<br />
beta p = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- componentes :: Prop -> [Prop]<br />
-- tal que (componentes ) es la lista de las componentes de la fórmula<br />
-- f. Por ejemplo, <br />
-- componentes (p /\ q --> r) ==> [no (p /\ q),r]<br />
-- componentes (no (p /\ q --> r)) ==> [(p /\ q),no r]<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
componentes :: Prop -> [Prop]<br />
componentes (Conj p q) = [p,q]<br />
componentes (Neg(Impl p q)) = [p,no q]<br />
componentes (Neg(Disj p q))= [no p, no q]<br />
componentes (Equi p q) = [Impl p q, Impl q p]<br />
componentes (Disj p q) = [p, q]<br />
componentes (Impl p q) = [no p, q]<br />
componentes (Neg(Conj p q))= [no p, no q]<br />
componentes (Neg(Equi p q))=[Neg(Impl p q), Neg(Impl q p)]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos mediante tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- conjuntoDeLiterales :: [Prop] -> Bool<br />
-- tal que (conjuntoDeLiterales fs) se verifica si fs es un conjunto de<br />
-- literales. Por ejemplo, <br />
-- conjuntoDeLiterales [p --> q, no r, r /\ s, p] ==> False<br />
-- conjuntoDeLiterales [p, no q, r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
conjuntoDeLiterales :: [Prop] -> Bool<br />
conjuntoDeLiterales []= True<br />
conjuntoDeLiterales (x:xs)= if literal x then conjuntoDeLiterales xs<br />
else False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- tieneContradicción :: [Prop] -> Bool<br />
-- tal que (tieneContradicción fs) se verifica si fs contiene una<br />
-- fórmula y su negación. Por ejemplo,<br />
-- tieneContradicción [r, p /\ q, s, no(p /\ q)] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
tieneContradiccion :: [Prop] -> Bool<br />
tieneContradiccion [x] = False<br />
tieneContradiccion (x:xs)= if elem (no x) xs then True else<br />
tieneContradiccion xs<br />
<br />
<br />
-- Isabel Duarte<br />
tieneContradiccion2 :: [Prop] -> Bool<br />
tieneContradiccion2 fs = or [elem (no x) fs | x <- fs]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónDN fs f) es la expansión de fs mediante la doble<br />
-- negación f. Por ejemplo,<br />
-- expansiónDN [p, no(no q), r] (no(no q)) ==> [[q,p,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
expansiónDN fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónAlfa fs f) es la expansión de fs mediante la<br />
-- fórmula alfa f. Por ejemplo,<br />
-- expansiónAlfa [q, (p1 /\ p2) , r] (p1 /\ p2) ==> [[p1,p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
expansiónAlfa fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónBeta fs f) es la expansión de fs mediante la<br />
-- fórmula beta f. Por ejemplo,<br />
-- expansiónBeta [q, (p1 \/ p2) , r] (p1 \/ p2) ==> [[p1,q,r],[p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
expansiónBeta fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- sucesores :: [Prop] -> [[Prop]]<br />
-- tal que (sucesores fs) es la lista de sucesores de fs. Por ejemplo,<br />
-- sucesores [q \/ s, no(no r), p1 /\ p2] => [[r,(q \/ s),(p1 /\ p2)]]<br />
-- sucesores [r,(q \/ s),(p1 /\ p2)] => [[p1,p2,r,(q \/ s)]]<br />
-- sucesores [p1,p2,r,(q \/ s)] => [[q,p1,p2,r],[s,p1,p2,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
sucesores :: [Prop] -> [[Prop]]<br />
sucesores fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosTab :: [Prop] -> [[Prop]]<br />
-- tal que (modelosTab fs) es el conjunto de los modelos de fs<br />
-- calculados mediante el método de tableros semánticos. Por ejemplo,<br />
-- modelosTab [p --> q, no(q --> p)] <br />
-- ==> [[no p,q],[q,no p]]<br />
-- modelosTab [p --> q, no q --> no p] <br />
-- ==> [[q,no p],[no p],[q],[no p,q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosTab :: [Prop] -> [[Prop]]<br />
modelosTab fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- subconjunto :: Eq a => [a] -> [a] -> Bool<br />
-- tal que (subconjunto x y) se verifica si x es subconjunto de y. Por<br />
-- ejemplo, <br />
-- subconjunto [1,3] [3,2,1] ==> True<br />
-- subconjunto [1,3,5] [3,2,1] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
subconjunto :: Eq a => [a] -> [a] -> Bool<br />
subconjunto xs ys = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- modelosGenerales :: [Prop] -> [[Prop]]<br />
-- tal que (modelosGenerales fs) es el conjunto de los modelos generales<br />
-- de fs calculados mediante el método de tableros semánticos. Por<br />
-- ejemplo, <br />
-- modelosGenerales [p --> q, no q --> no p] ==> [[no p],[q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosGenerales :: [Prop] -> [[Prop]]<br />
modelosGenerales fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Teoremas por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esTeoremaPorTableros :: Prop -> Bool<br />
-- tal que (esTeoremaPorTableros f) se verifica si la fórmula f es<br />
-- teorema (mediante tableros semánticos). Por ejemplo, <br />
-- esTeoremaPorTableros (p --> p) ==> True<br />
-- esTeoremaPorTableros (p --> q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esTeoremaPorTableros :: Prop -> Bool<br />
esTeoremaPorTableros f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
-- tal que (esDeduciblePorTableros fs f) se verifica si la fórmula f es<br />
-- consecuencia (mediante tableros) del conjunto de fórmulas fs. Por<br />
-- ejemplo,<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p --> r) ==> True<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p <--> r) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
esDeduciblePorTableros fs f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_8&diff=433
Relación 8
2013-04-24T11:12:45Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
<br />
-- TablerosSemánticos.hs<br />
-- Tableros semánticos proposicionales.<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module TablerosSemanticos where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 0: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- "Pedro Ros"<br />
literal :: Prop -> Bool<br />
literal (Atom p) = True<br />
literal (Neg (Atom p)) = True<br />
literal x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Notación uniforme --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- dobleNegación :: Prop -> Bool<br />
-- tal que (dobleNegación f) se verifica si f es una doble negación. Por<br />
-- ejemplo, <br />
-- dobleNegación (no (no p)) ==> True<br />
-- dobleNegación (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
dobleNegacion :: Prop -> Bool<br />
dobleNegacion (Neg (Neg p))= True<br />
dobleNegacion x = False<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- alfa :: Prop -> Bool<br />
-- tal que (alfa f) se verifica si f es una fórmula alfa.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
alfa :: Prop -> Bool<br />
alfa (Conj p q) = True<br />
alfa (Neg (Impl p q))= True<br />
alfa (Neg (Disj p q))= True<br />
alfa (Equi p q) = True<br />
alfa x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- beta :: Prop -> Bool<br />
-- tal que (beta d) se verifica si f es una fórmula beta.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
beta :: Prop -> Bool<br />
beta (Disj p q) = True<br />
beta (Impl p q) = True<br />
beta (Neg (Conj p q)) = True<br />
beta (Neg (Equi p q))= True<br />
beta p = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- componentes :: Prop -> [Prop]<br />
-- tal que (componentes ) es la lista de las componentes de la fórmula<br />
-- f. Por ejemplo, <br />
-- componentes (p /\ q --> r) ==> [no (p /\ q),r]<br />
-- componentes (no (p /\ q --> r)) ==> [(p /\ q),no r]<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
componentes :: Prop -> [Prop]<br />
componentes (Conj p q) = [p,q]<br />
componentes (Neg(Impl p q)) = [p,no q]<br />
componentes (Neg(Disj p q))= [no p, no q]<br />
componentes (Equi p q) = [Impl p q, Impl q p]<br />
componentes (Disj p q) = [p, q]<br />
componentes (Impl p q) = [no p, q]<br />
componentes (Neg(Conj p q))= [no p, no q]<br />
componentes (Neg(Equi p q))=[Neg(Impl p q), Neg(Impl q p)]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos mediante tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- conjuntoDeLiterales :: [Prop] -> Bool<br />
-- tal que (conjuntoDeLiterales fs) se verifica si fs es un conjunto de<br />
-- literales. Por ejemplo, <br />
-- conjuntoDeLiterales [p --> q, no r, r /\ s, p] ==> False<br />
-- conjuntoDeLiterales [p, no q, r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
conjuntoDeLiterales :: [Prop] -> Bool<br />
conjuntoDeLiterales []= True<br />
conjuntoDeLiterales (x:xs)= if literal x then conjuntoDeLiterales xs<br />
else False<br />
<br />
-- Isabel Duarte<br />
tieneContradiccion2 :: [Prop] -> Bool<br />
tieneContradiccion2 fs = or [elem (no x) fs | x <- fs]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- tieneContradicción :: [Prop] -> Bool<br />
-- tal que (tieneContradicción fs) se verifica si fs contiene una<br />
-- fórmula y su negación. Por ejemplo,<br />
-- tieneContradicción [r, p /\ q, s, no(p /\ q)] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
tieneContradiccion :: [Prop] -> Bool<br />
tieneContradiccion [x] = False<br />
tieneContradiccion (x:xs)= if elem (no x) xs then True else<br />
tieneContradiccion xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónDN fs f) es la expansión de fs mediante la doble<br />
-- negación f. Por ejemplo,<br />
-- expansiónDN [p, no(no q), r] (no(no q)) ==> [[q,p,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
expansiónDN fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónAlfa fs f) es la expansión de fs mediante la<br />
-- fórmula alfa f. Por ejemplo,<br />
-- expansiónAlfa [q, (p1 /\ p2) , r] (p1 /\ p2) ==> [[p1,p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
expansiónAlfa fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónBeta fs f) es la expansión de fs mediante la<br />
-- fórmula beta f. Por ejemplo,<br />
-- expansiónBeta [q, (p1 \/ p2) , r] (p1 \/ p2) ==> [[p1,q,r],[p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
expansiónBeta fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- sucesores :: [Prop] -> [[Prop]]<br />
-- tal que (sucesores fs) es la lista de sucesores de fs. Por ejemplo,<br />
-- sucesores [q \/ s, no(no r), p1 /\ p2] => [[r,(q \/ s),(p1 /\ p2)]]<br />
-- sucesores [r,(q \/ s),(p1 /\ p2)] => [[p1,p2,r,(q \/ s)]]<br />
-- sucesores [p1,p2,r,(q \/ s)] => [[q,p1,p2,r],[s,p1,p2,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
sucesores :: [Prop] -> [[Prop]]<br />
sucesores fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosTab :: [Prop] -> [[Prop]]<br />
-- tal que (modelosTab fs) es el conjunto de los modelos de fs<br />
-- calculados mediante el método de tableros semánticos. Por ejemplo,<br />
-- modelosTab [p --> q, no(q --> p)] <br />
-- ==> [[no p,q],[q,no p]]<br />
-- modelosTab [p --> q, no q --> no p] <br />
-- ==> [[q,no p],[no p],[q],[no p,q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosTab :: [Prop] -> [[Prop]]<br />
modelosTab fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- subconjunto :: Eq a => [a] -> [a] -> Bool<br />
-- tal que (subconjunto x y) se verifica si x es subconjunto de y. Por<br />
-- ejemplo, <br />
-- subconjunto [1,3] [3,2,1] ==> True<br />
-- subconjunto [1,3,5] [3,2,1] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
subconjunto :: Eq a => [a] -> [a] -> Bool<br />
subconjunto xs ys = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- modelosGenerales :: [Prop] -> [[Prop]]<br />
-- tal que (modelosGenerales fs) es el conjunto de los modelos generales<br />
-- de fs calculados mediante el método de tableros semánticos. Por<br />
-- ejemplo, <br />
-- modelosGenerales [p --> q, no q --> no p] ==> [[no p],[q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosGenerales :: [Prop] -> [[Prop]]<br />
modelosGenerales fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Teoremas por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esTeoremaPorTableros :: Prop -> Bool<br />
-- tal que (esTeoremaPorTableros f) se verifica si la fórmula f es<br />
-- teorema (mediante tableros semánticos). Por ejemplo, <br />
-- esTeoremaPorTableros (p --> p) ==> True<br />
-- esTeoremaPorTableros (p --> q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esTeoremaPorTableros :: Prop -> Bool<br />
esTeoremaPorTableros f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
-- tal que (esDeduciblePorTableros fs f) se verifica si la fórmula f es<br />
-- consecuencia (mediante tableros) del conjunto de fórmulas fs. Por<br />
-- ejemplo,<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p --> r) ==> True<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p <--> r) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
esDeduciblePorTableros fs f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_8&diff=432
Relación 8
2013-04-24T11:12:29Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
<br />
-- TablerosSemánticos.hs<br />
-- Tableros semánticos proposicionales.<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module TablerosSemanticos where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import SintaxisSemantica<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Literales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 0: Definir la función<br />
-- literal :: Prop -> Bool<br />
-- tal que (literal f) se verifica si la fórmula F es un literal. Por<br />
-- ejemplo, <br />
-- literal p ==> True<br />
-- literal (no p) ==> True<br />
-- literal (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- "Pedro Ros"<br />
literal :: Prop -> Bool<br />
literal (Atom p) = True<br />
literal (Neg (Atom p)) = True<br />
literal x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Notación uniforme --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir la función<br />
-- dobleNegación :: Prop -> Bool<br />
-- tal que (dobleNegación f) se verifica si f es una doble negación. Por<br />
-- ejemplo, <br />
-- dobleNegación (no (no p)) ==> True<br />
-- dobleNegación (no (p --> q)) ==> False<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
dobleNegacion :: Prop -> Bool<br />
dobleNegacion (Neg (Neg p))= True<br />
dobleNegacion x = False<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir la función<br />
-- alfa :: Prop -> Bool<br />
-- tal que (alfa f) se verifica si f es una fórmula alfa.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
alfa :: Prop -> Bool<br />
alfa (Conj p q) = True<br />
alfa (Neg (Impl p q))= True<br />
alfa (Neg (Disj p q))= True<br />
alfa (Equi p q) = True<br />
alfa x = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- beta :: Prop -> Bool<br />
-- tal que (beta d) se verifica si f es una fórmula beta.<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
beta :: Prop -> Bool<br />
beta (Disj p q) = True<br />
beta (Impl p q) = True<br />
beta (Neg (Conj p q)) = True<br />
beta (Neg (Equi p q))= True<br />
beta p = False<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir la función<br />
-- componentes :: Prop -> [Prop]<br />
-- tal que (componentes ) es la lista de las componentes de la fórmula<br />
-- f. Por ejemplo, <br />
-- componentes (p /\ q --> r) ==> [no (p /\ q),r]<br />
-- componentes (no (p /\ q --> r)) ==> [(p /\ q),no r]<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
componentes :: Prop -> [Prop]<br />
componentes (Conj p q) = [p,q]<br />
componentes (Neg(Impl p q)) = [p,no q]<br />
componentes (Neg(Disj p q))= [no p, no q]<br />
componentes (Equi p q) = [Impl p q, Impl q p]<br />
componentes (Disj p q) = [p, q]<br />
componentes (Impl p q) = [no p, q]<br />
componentes (Neg(Conj p q))= [no p, no q]<br />
componentes (Neg(Equi p q))=[Neg(Impl p q), Neg(Impl q p)]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos mediante tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- conjuntoDeLiterales :: [Prop] -> Bool<br />
-- tal que (conjuntoDeLiterales fs) se verifica si fs es un conjunto de<br />
-- literales. Por ejemplo, <br />
-- conjuntoDeLiterales [p --> q, no r, r /\ s, p] ==> False<br />
-- conjuntoDeLiterales [p, no q, r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
conjuntoDeLiterales :: [Prop] -> Bool<br />
conjuntoDeLiterales []= True<br />
conjuntoDeLiterales (x:xs)= if literal x then conjuntoDeLiterales xs<br />
else False<br />
<br />
-- Isabel Duarte<br />
tieneContradiccion :: [Prop] -> Bool<br />
tieneContradiccion fs = or [elem (no x) fs | x <- fs]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir la función<br />
-- tieneContradicción :: [Prop] -> Bool<br />
-- tal que (tieneContradicción fs) se verifica si fs contiene una<br />
-- fórmula y su negación. Por ejemplo,<br />
-- tieneContradicción [r, p /\ q, s, no(p /\ q)] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro Ros<br />
tieneContradiccion :: [Prop] -> Bool<br />
tieneContradiccion [x] = False<br />
tieneContradiccion (x:xs)= if elem (no x) xs then True else<br />
tieneContradiccion xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónDN fs f) es la expansión de fs mediante la doble<br />
-- negación f. Por ejemplo,<br />
-- expansiónDN [p, no(no q), r] (no(no q)) ==> [[q,p,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónDN :: [Prop] -> Prop -> [[Prop]]<br />
expansiónDN fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónAlfa fs f) es la expansión de fs mediante la<br />
-- fórmula alfa f. Por ejemplo,<br />
-- expansiónAlfa [q, (p1 /\ p2) , r] (p1 /\ p2) ==> [[p1,p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónAlfa :: [Prop] -> Prop -> [[Prop]]<br />
expansiónAlfa fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
-- tal que (expansiónBeta fs f) es la expansión de fs mediante la<br />
-- fórmula beta f. Por ejemplo,<br />
-- expansiónBeta [q, (p1 \/ p2) , r] (p1 \/ p2) ==> [[p1,q,r],[p2,q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
expansiónBeta :: [Prop] -> Prop -> [[Prop]]<br />
expansiónBeta fs f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- sucesores :: [Prop] -> [[Prop]]<br />
-- tal que (sucesores fs) es la lista de sucesores de fs. Por ejemplo,<br />
-- sucesores [q \/ s, no(no r), p1 /\ p2] => [[r,(q \/ s),(p1 /\ p2)]]<br />
-- sucesores [r,(q \/ s),(p1 /\ p2)] => [[p1,p2,r,(q \/ s)]]<br />
-- sucesores [p1,p2,r,(q \/ s)] => [[q,p1,p2,r],[s,p1,p2,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
sucesores :: [Prop] -> [[Prop]]<br />
sucesores fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosTab :: [Prop] -> [[Prop]]<br />
-- tal que (modelosTab fs) es el conjunto de los modelos de fs<br />
-- calculados mediante el método de tableros semánticos. Por ejemplo,<br />
-- modelosTab [p --> q, no(q --> p)] <br />
-- ==> [[no p,q],[q,no p]]<br />
-- modelosTab [p --> q, no q --> no p] <br />
-- ==> [[q,no p],[no p],[q],[no p,q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosTab :: [Prop] -> [[Prop]]<br />
modelosTab fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- subconjunto :: Eq a => [a] -> [a] -> Bool<br />
-- tal que (subconjunto x y) se verifica si x es subconjunto de y. Por<br />
-- ejemplo, <br />
-- subconjunto [1,3] [3,2,1] ==> True<br />
-- subconjunto [1,3,5] [3,2,1] ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
subconjunto :: Eq a => [a] -> [a] -> Bool<br />
subconjunto xs ys = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- modelosGenerales :: [Prop] -> [[Prop]]<br />
-- tal que (modelosGenerales fs) es el conjunto de los modelos generales<br />
-- de fs calculados mediante el método de tableros semánticos. Por<br />
-- ejemplo, <br />
-- modelosGenerales [p --> q, no q --> no p] ==> [[no p],[q]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosGenerales :: [Prop] -> [[Prop]]<br />
modelosGenerales fs = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Teoremas por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esTeoremaPorTableros :: Prop -> Bool<br />
-- tal que (esTeoremaPorTableros f) se verifica si la fórmula f es<br />
-- teorema (mediante tableros semánticos). Por ejemplo, <br />
-- esTeoremaPorTableros (p --> p) ==> True<br />
-- esTeoremaPorTableros (p --> q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esTeoremaPorTableros :: Prop -> Bool<br />
esTeoremaPorTableros f = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia por tableros --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
-- tal que (esDeduciblePorTableros fs f) se verifica si la fórmula f es<br />
-- consecuencia (mediante tableros) del conjunto de fórmulas fs. Por<br />
-- ejemplo,<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p --> r) ==> True<br />
-- esDeduciblePorTableros [p --> q, q --> r] (p <--> r) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esDeduciblePorTableros :: [Prop] -> Prop -> Bool<br />
esDeduciblePorTableros fs f = undefined<br />
<br />
<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Ejercicio_2&diff=400
Ejercicio 2
2013-04-12T12:45:42Z
<p>Isaduatos: /* Selección del ejercicio */</p>
<hr />
<div>== Enunciado ==<br />
El segundo ejercicio evaluable consiste en la realización de una demostración por deducción natural en la Lógica de primer orden, con Isabelle/HOL.<br />
Para ello, <br />
* Cada alumno elegirá uno de los ejercicios propuestos en [[T2|T2]].<br />
* Una vez elegido, lo anotará en la lista que se muestra a continuación, no pudiendo un mismo ejercicio ser elegido por más de un alumno. <br />
* El ejercicio resuelto se enviará a mjoseh@us.es en un fichero usuario_2.thy antes del viernes 26 de abril de 2013.<br />
* En la valoración del ejercicio se tendrá en cuenta tanto el nivel de dificultad como la calidad de la demostración.<br />
<br />
== Selección del ejercicio ==<br />
<br />
* Ejercicio 1: Francisco Vilches Chacón<br />
* Ejercicio 2: <br />
* Ejercicio 3: <br />
* Ejercicio 4: <br />
* Ejercicio 5: <br />
* Ejercicio 6: <br />
* Ejercicio 7: <br />
* Ejercicio 8: <br />
* Ejercicio 9: <br />
* Ejercicio 10: <br />
* Ejercicio 11: <br />
* Ejercicio 12: <br />
* Ejercicio 13: <br />
* Ejercicio 14: <br />
* Ejercicio 15: <br />
* Ejercicio 16: <br />
* Ejercicio 17: <br />
* Ejercicio 18: <br />
* Ejercicio 19: <br />
* Ejercicio 20: <br />
* Ejercicio 21: <br />
* Ejercicio 22: <br />
* Ejercicio 23: Irene Araujo Guijo<br />
* Ejercicio 24: <br />
* Ejercicio 25: <br />
* Ejercicio 26: <br />
* Ejercicio 27: FºJavier Sanz Gil<br />
* Ejercicio 28: Isabel Duarte Tosso<br />
* Ejercicio 29: <br />
* Ejercicio 30: <br />
* Ejercicio 31: <br />
* Ejercicio 32: <br />
* Ejercicio 33:</div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_3&diff=167
Relación 3
2013-03-08T11:20:37Z
<p>Isaduatos: </p>
<hr />
<div><source lang="isar"><br />
header {* R3: Deducción natural proposicional *}<br />
<br />
theory R3<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es demostrar cada uno de los ejercicios<br />
usando sólo las reglas básicas de deducción natural de la lógica<br />
proposicional (sin usar el método auto).<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 />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación. *}<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, p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_1a:<br />
assumes 1: "p ⟶ q" and<br />
2: "p"<br />
shows "q"<br />
proof -<br />
show 3: "q" using 1 2 by (rule mp) <br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_1b:<br />
assumes "p ⟶ q"<br />
"p"<br />
shows "q"<br />
proof -<br />
show "q" using assms(1,2) by (rule mp)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ q, q ⟶ r, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_2a:<br />
assumes 1:"p ⟶ q" and<br />
2:"q ⟶ r" and<br />
3:"p" <br />
shows "r"<br />
proof -<br />
have 4: "q" using 1 3 by (rule mp)<br />
show 5: "r" using 2 4 by (rule mp) <br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_2b:<br />
assumes "p ⟶ q"<br />
"q ⟶ r"<br />
"p" <br />
shows "r"<br />
proof -<br />
have "q" using assms(1,3) ..<br />
with `q ⟶ r` show "r" ..<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_3a:<br />
assumes 1: "p ⟶ (q ⟶ r)" and<br />
2: "p ⟶ q" and<br />
3: "p" <br />
shows "r"<br />
proof -<br />
have 4: "q ⟶ r" using 1 3 by (rule mp)<br />
have 5: "q" using 2 3 by (rule mp)<br />
show 6: "r" using 4 5 by (rule mp)<br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_3b:<br />
assumes "p ⟶ (q ⟶ r)" <br />
"p ⟶ q"<br />
"p" <br />
shows "r"<br />
proof -<br />
have "q ⟶ r" using assms(1,3) ..<br />
have "q" using assms(2,3) ..<br />
with `q ⟶ r` show "r" ..<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
p ⟶ q, q ⟶ r ⊢ p ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_4a:<br />
assumes 1: "p ⟶ q" and<br />
2: "q ⟶ r" <br />
shows "p ⟶ r"<br />
proof -<br />
{assume 3:"p" <br />
have 4: "q" using 1 3 by (rule mp)<br />
have 5: "r" using 2 4 by (rule mp)}<br />
thus "p ⟶ r" by (rule impI)<br />
qed<br />
<br />
<br />
lemma ejercicio_4d:<br />
assumes "p ⟶ q" and<br />
"q ⟶ r" <br />
shows "p ⟶ r"<br />
using assms by auto<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_5a:<br />
assumes 1: "p ⟶ (q ⟶ r)" <br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 3: "q"<br />
{assume 4: "p"<br />
have "q ⟶ r" using 1 4 ..<br />
hence 5: "r" using 3 ..}<br />
hence 6: "p ⟶ r" by (rule impI)}<br />
thus "q ⟶ (p ⟶ r)" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "José Mª Contreras"<br />
lemma ejercicio_6a:<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 ⟶ r" using 1 3 ..<br />
have 5: "q" using 2 3 ..<br />
have "r" using 4 5 ..}<br />
hence "p ⟶ r" by (rule impI)}<br />
thus "(p ⟶ q) ⟶ (p ⟶ r)" by (rule impI)<br />
qed <br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ⊢ q ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_7:<br />
assumes "p" <br />
shows "q ⟶ p"<br />
proof -<br />
{assume 1: "q"}<br />
show "q⟶ p" using assms(1) by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
⊢ p ⟶ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_8:<br />
"p ⟶ (q ⟶ p)"<br />
proof -<br />
{assume 1: "p"<br />
hence 2: "q ⟶ p" by (rule impI)}<br />
thus "p ⟶q⟶p" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
<br />
-- Carmen Martinez Navarro, Erlinda Menendez Perez <br />
<br />
<br />
lemma ejercicio_9:<br />
assumes 1: "p ⟶ q"<br />
shows "(q ⟶ r) ⟶ (p ⟶ r)"<br />
proof- <br />
{assume 2: "q ⟶ r"<br />
{assume 3: "p"<br />
have 4: "q" using 1 3 by (rule mp)<br />
have 5: "r" using 2 4 by (rule mp)}<br />
hence 6: "p ⟶ r" by (rule impI)}<br />
thus "(q ⟶ r) ⟶ (p ⟶ r)" by (rule impI)<br />
qed<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_10:<br />
assumes "p ⟶ (q ⟶ (r ⟶ s))" <br />
shows "r ⟶ (q ⟶ (p ⟶ s))"<br />
proof <br />
assume "r"<br />
show "q⟶ (p⟶ s)" <br />
proof <br />
assume "q"<br />
show "p⟶ s"<br />
proof<br />
assume "p"<br />
with assms have "q⟶ r⟶ s" ..<br />
hence "r⟶ s" using `q` ..<br />
thus "s" using `r`..<br />
qed<br />
qed <br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_11:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 12. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_12:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 13. Demostrar<br />
p, q ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros Reina"<br />
<br />
lemma ejercicio_13:<br />
assumes 1:"p" and<br />
2:"q" <br />
shows "p ∧ q"<br />
proof -<br />
show "p ∧ q" using 1 2 by (rule conjI)<br />
qed<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 14. Demostrar<br />
p ∧ q ⊢ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_14:<br />
assumes "p ∧ q" <br />
shows "p"<br />
proof -<br />
show "p" using assms by (rule conjunct1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 15. Demostrar<br />
p ∧ q ⊢ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_15:<br />
assumes "p ∧ q" <br />
shows "q"<br />
proof -<br />
show "q" using assms by (rule conjunct2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 16. Demostrar<br />
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_16:<br />
assumes "p ∧ (q ∧ r)"<br />
shows "(p ∧ q)∧ r"<br />
proof -<br />
have 1: "p" using assms by (rule conjunct1)<br />
have 2: "(q ∧ r)" using assms by (rule conjunct2)<br />
have 3: "q" using 2 by (rule conjunct1)<br />
have 4: "r" using 2 by (rule conjunct2)<br />
have 5: "(p∧q)" using 1 3 by (rule conjI)<br />
show 6: "(p∧q) ∧ r" using 5 4 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 17. Demostrar<br />
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_17:<br />
assumes "(p∧ q) ∧ r" <br />
shows "p ∧ (q∧ r)"<br />
proof -<br />
have 1: "r" using assms by (rule conjunct2)<br />
have 2: "(p∧q)" using assms by (rule conjunct1)<br />
have 3: "p" using 2 by (rule conjunct1)<br />
have 4: "q" using 2 by (rule conjunct2)<br />
have 5: "(q∧r)" using 4 1 by (rule conjI)<br />
show 6: "p∧(q∧r)" using 3 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 18. Demostrar<br />
p ∧ q ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_18:<br />
assumes "p ∧ q" <br />
shows "p ⟶ q"<br />
proof -<br />
have 1: "q" using assms by (rule conjunct2)<br />
show "p⟶ q" using 1 by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 19. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
--Carmen Martinez Navarro , Erlinda Menendez Perez<br />
<br />
<br />
<br />
lemma ejercicio_19:<br />
assumes 1: "(p ⟶ q) ∧ (p ⟶ r)" <br />
shows "p ⟶ (q ∧ r)"<br />
proof (rule impI)<br />
assume 2: "p"<br />
have 3: "p ⟶ q" using assms by (rule conjunct1)<br />
have 4: "q" using 3 2 by (rule mp)<br />
have 5: "p ⟶ r" using assms by (rule conjunct2)<br />
have 6: "r" using 5 2 by (rule mp)<br />
show "q ∧ r" using 4 6 by (rule conjI)<br />
qed<br />
<br />
<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 20. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_20:<br />
assumes "p ⟶ q ∧ r" <br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 21. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_21:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 22. Demostrar<br />
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_22:<br />
assumes "p ∧ q ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 23. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_23:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 24. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_24:<br />
assumes "p ∧ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ r"<br />
oops<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 25. Demostrar<br />
p ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_25:<br />
assumes "p"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 26. Demostrar<br />
q ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_26:<br />
assumes "q"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 27. Demostrar<br />
p ∨ q ⊢ q ∨ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_27:<br />
assumes "p ∨ q"<br />
shows "q ∨ p"<br />
proof - <br />
have "p ∨ q" using assms by this<br />
moreover<br />
{ assume 2: "p"<br />
have "q ∨ p" using 2 by (rule disjI2) }<br />
moreover<br />
{ assume 3: "q"<br />
have "q ∨ p" using 3 by (rule disjI1) }<br />
ultimately show "q ∨ p" by (rule disjE) <br />
qed <br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 28. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_28:<br />
assumes "q ⟶ r" <br />
shows "p ∨ q ⟶ p ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 29. Demostrar<br />
p ∨ p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_29:<br />
assumes "p ∨ p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 30. Demostrar<br />
p ⊢ p ∨ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_30:<br />
assumes "p" <br />
shows "p ∨ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 31. Demostrar<br />
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_31:<br />
assumes "p ∨ (q ∨ r)" <br />
shows "(p ∨ q) ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 32. Demostrar<br />
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_32:<br />
assumes "(p ∨ q) ∨ r" <br />
shows "p ∨ (q ∨ r)"<br />
using assms(1)<br />
proof<br />
assume "p∨q"<br />
thus "p∨q∨r" <br />
proof<br />
assume "p"<br />
thus "p∨q∨r" ..<br />
next<br />
assume "q"<br />
hence "q∨r" ..<br />
thus "p∨q∨r" ..<br />
qed<br />
next<br />
assume "r"<br />
hence "q∨r" ..<br />
thus "p∨q∨r" ..<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 33. Demostrar<br />
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_33:<br />
assumes "p ∧ (q ∨ r)" <br />
shows "(p ∧ q) ∨ (p ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 34. Demostrar<br />
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_34:<br />
assumes "(p ∧ q) ∨ (p ∧ r)" <br />
shows "p ∧ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 35. Demostrar<br />
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_35:<br />
assumes "p ∨ (q ∧ r)" <br />
shows "(p ∨ q) ∧ (p ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 36. Demostrar<br />
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_36:<br />
assumes "(p ∨ q) ∧ (p ∨ r)"<br />
shows "p ∨ (q ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 37. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_37:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)" <br />
shows "p ∨ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 38. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_38:<br />
assumes "p ∨ q ⟶ r" <br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
oops<br />
<br />
section {* Negaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 39. Demostrar<br />
p ⊢ ¬¬p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_39:<br />
assumes "p"<br />
shows "¬¬p"<br />
proof -<br />
show "¬¬p" using assms by (rule notnotI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_40:<br />
assumes "¬p" <br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 41. Demostrar<br />
p ⟶ q ⊢ ¬q ⟶ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_41:<br />
assumes "p ⟶ q"<br />
shows "¬q ⟶ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p∨q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_42:<br />
assumes "p∨q"<br />
"¬q" <br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p ∨ q, ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_43:<br />
assumes "p ∨ q"<br />
"¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
p ∨ q ⊢ ¬(¬p ∧ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_44:<br />
assumes "p ∨ q" <br />
shows "¬(¬p ∧ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 45. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_45:<br />
assumes "p ∧ q" <br />
shows "¬(¬p ∨ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 46. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_46:<br />
assumes "¬(p ∨ q)" <br />
shows "¬p ∧ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 47. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_47:<br />
assumes "¬p ∧ ¬q" <br />
shows "¬(p ∨ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 48. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_48:<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 49. Demostrar<br />
⊢ ¬(p ∧ ¬p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_49:<br />
"¬(p ∧ ¬p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 50. Demostrar<br />
p ∧ ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_50:<br />
assumes "p ∧ ¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 51. Demostrar<br />
¬¬p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_51:<br />
assumes "¬¬p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 52. Demostrar<br />
⊢ p ∨ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_52:<br />
"p ∨ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 53. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_53:<br />
"((p ⟶ q) ⟶ p) ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 54. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_54:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 55. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_55:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 56. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_56:<br />
assumes "¬(¬p ∨ ¬q)" <br />
shows "p ∧ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 57. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_57:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 58. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_58:<br />
"(p ⟶ q) ∨ (q ⟶ p)"<br />
oops<br />
<br />
end<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_3&diff=152
Relación 3
2013-03-05T14:19:31Z
<p>Isaduatos: </p>
<hr />
<div><source lang="isar"><br />
header {* R3: Deducción natural proposicional *}<br />
<br />
theory R3<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es demostrar cada uno de los ejercicios<br />
usando sólo las reglas básicas de deducción natural de la lógica<br />
proposicional (sin usar el método auto).<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 />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación. *}<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, p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_1a:<br />
assumes 1: "p ⟶ q" and<br />
2: "p"<br />
shows "q"<br />
proof -<br />
show 3: "q" using 1 2 by (rule mp) <br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_1b:<br />
assumes "p ⟶ q"<br />
"p"<br />
shows "q"<br />
proof -<br />
show "q" using assms(1,2) by (rule mp)<br />
qed<br />
<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ q, q ⟶ r, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_2a:<br />
assumes 1:"p ⟶ q" and<br />
2:"q ⟶ r" and<br />
3:"p" <br />
shows "r"<br />
proof -<br />
have 4: "q" using 1 3 by (rule mp)<br />
show 5: "r" using 2 4 by (rule mp) <br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_3a:<br />
assumes 1: "p ⟶ (q ⟶ r)" and<br />
2: "p ⟶ q" and<br />
3: "p" <br />
shows "r"<br />
proof -<br />
have 4: "q ⟶ r" using 1 3 by (rule mp)<br />
have 5: "q" using 2 3 by (rule mp)<br />
show 6: "r" using 4 5 by (rule mp)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
p ⟶ q, q ⟶ r ⊢ p ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_4a:<br />
assumes 1: "p ⟶ q" and<br />
2: "q ⟶ r" <br />
shows "p ⟶ r"<br />
proof -<br />
{assume 3:"p" <br />
have 4: "q" using 1 3 by (rule mp)<br />
have 5: "r" using 2 4 by (rule mp)}<br />
thus "p⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
--"Isabel Duarte"<br />
<br />
lemma ejercicio_5a:<br />
assumes 1: "p ⟶ (q ⟶ r)" <br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 3: "q"<br />
{assume 4: "p"<br />
have "q ⟶ r" using 1 4 ..<br />
hence 5: "r" using 3 ..}<br />
hence 6: "p ⟶ r" by (rule impI)}<br />
thus "q ⟶ (p ⟶ r)" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_6:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ⊢ q ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_7:<br />
assumes "p" <br />
shows "q ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
⊢ p ⟶ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_8:<br />
"p ⟶ (q ⟶ p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_9:<br />
assumes "p ⟶ q" <br />
shows "(q ⟶ r) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_10:<br />
assumes "p ⟶ (q ⟶ (r ⟶ s))" <br />
shows "r ⟶ (q ⟶ (p ⟶ s))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_11:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 12. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_12:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 13. Demostrar<br />
p, q ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros Reina"<br />
<br />
lemma ejercicio_13:<br />
assumes 1:"p" and<br />
2:"q" <br />
shows "p ∧ q"<br />
proof -<br />
show "p ∧ q" using 1 2 by (rule conjI)<br />
qed<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 14. Demostrar<br />
p ∧ q ⊢ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_14:<br />
assumes "p ∧ q" <br />
shows "p"<br />
proof -<br />
show "p" using assms by (rule conjunct1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 15. Demostrar<br />
p ∧ q ⊢ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_15:<br />
assumes "p ∧ q" <br />
shows "q"<br />
proof -<br />
show "q" using assms by (rule conjunct2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 16. Demostrar<br />
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_16:<br />
assumes "p ∧ (q ∧ r)"<br />
shows "(p ∧ q)∧ r"<br />
proof -<br />
have 1: "p" using assms by (rule conjunct1)<br />
have 2: "(q ∧ r)" using assms by (rule conjunct2)<br />
have 3: "q" using 2 by (rule conjunct1)<br />
have 4: "r" using 2 by (rule conjunct2)<br />
have 5: "(p∧q)" using 1 3 by (rule conjI)<br />
show 6: "(p∧q) ∧ r" using 5 4 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 17. Demostrar<br />
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_17:<br />
assumes "(p∧ q) ∧ r" <br />
shows "p ∧ (q∧ r)"<br />
proof -<br />
have 1: "r" using assms by (rule conjunct2)<br />
have 2: "(p∧q)" using assms by (rule conjunct1)<br />
have 3: "p" using 2 by (rule conjunct1)<br />
have 4: "q" using 2 by (rule conjunct2)<br />
have 5: "(q∧r)" using 4 1 by (rule conjI)<br />
show 6: "p∧(q∧r)" using 3 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 18. Demostrar<br />
p ∧ q ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_18:<br />
assumes "p ∧ q" <br />
shows "p ⟶ q"<br />
proof -<br />
have 1: "q" using assms by (rule conjunct2)<br />
show "p⟶ q" using 1 by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 19. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_19:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)" <br />
shows "p ⟶ q ∧ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 20. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_20:<br />
assumes "p ⟶ q ∧ r" <br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 21. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_21:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 22. Demostrar<br />
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_22:<br />
assumes "p ∧ q ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 23. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_23:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 24. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_24:<br />
assumes "p ∧ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ r"<br />
oops<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 25. Demostrar<br />
p ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_25:<br />
assumes "p"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 26. Demostrar<br />
q ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_26:<br />
assumes "q"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 27. Demostrar<br />
p ∨ q ⊢ q ∨ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_27:<br />
assumes "p ∨ q"<br />
shows "q ∨ p"<br />
proof - <br />
have "p ∨ q" using assms by this<br />
moreover<br />
{ assume 2: "p"<br />
have "q ∨ p" using 2 by (rule disjI2) }<br />
moreover<br />
{ assume 3: "q"<br />
have "q ∨ p" using 3 by (rule disjI1) }<br />
ultimately show "q ∨ p" by (rule disjE) <br />
qed <br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 28. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_28:<br />
assumes "q ⟶ r" <br />
shows "p ∨ q ⟶ p ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 29. Demostrar<br />
p ∨ p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_29:<br />
assumes "p ∨ p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 30. Demostrar<br />
p ⊢ p ∨ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_30:<br />
assumes "p" <br />
shows "p ∨ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 31. Demostrar<br />
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_31:<br />
assumes "p ∨ (q ∨ r)" <br />
shows "(p ∨ q) ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 32. Demostrar<br />
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_32:<br />
assumes "(p ∨ q) ∨ r" <br />
shows "p ∨ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 33. Demostrar<br />
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_33:<br />
assumes "p ∧ (q ∨ r)" <br />
shows "(p ∧ q) ∨ (p ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 34. Demostrar<br />
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_34:<br />
assumes "(p ∧ q) ∨ (p ∧ r)" <br />
shows "p ∧ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 35. Demostrar<br />
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_35:<br />
assumes "p ∨ (q ∧ r)" <br />
shows "(p ∨ q) ∧ (p ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 36. Demostrar<br />
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_36:<br />
assumes "(p ∨ q) ∧ (p ∨ r)"<br />
shows "p ∨ (q ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 37. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_37:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)" <br />
shows "p ∨ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 38. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_38:<br />
assumes "p ∨ q ⟶ r" <br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
oops<br />
<br />
section {* Negaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 39. Demostrar<br />
p ⊢ ¬¬p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_39:<br />
assumes "p"<br />
shows "¬¬p"<br />
proof -<br />
show "¬¬p" using assms by (rule notnotI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_40:<br />
assumes "¬p" <br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 41. Demostrar<br />
p ⟶ q ⊢ ¬q ⟶ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_41:<br />
assumes "p ⟶ q"<br />
shows "¬q ⟶ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p∨q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_42:<br />
assumes "p∨q"<br />
"¬q" <br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p ∨ q, ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_43:<br />
assumes "p ∨ q"<br />
"¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
p ∨ q ⊢ ¬(¬p ∧ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_44:<br />
assumes "p ∨ q" <br />
shows "¬(¬p ∧ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 45. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_45:<br />
assumes "p ∧ q" <br />
shows "¬(¬p ∨ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 46. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_46:<br />
assumes "¬(p ∨ q)" <br />
shows "¬p ∧ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 47. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_47:<br />
assumes "¬p ∧ ¬q" <br />
shows "¬(p ∨ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 48. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_48:<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 49. Demostrar<br />
⊢ ¬(p ∧ ¬p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_49:<br />
"¬(p ∧ ¬p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 50. Demostrar<br />
p ∧ ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_50:<br />
assumes "p ∧ ¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 51. Demostrar<br />
¬¬p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_51:<br />
assumes "¬¬p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 52. Demostrar<br />
⊢ p ∨ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_52:<br />
"p ∨ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 53. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_53:<br />
"((p ⟶ q) ⟶ p) ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 54. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_54:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 55. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_55:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 56. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_56:<br />
assumes "¬(¬p ∨ ¬q)" <br />
shows "p ∧ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 57. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_57:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 58. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_58:<br />
"(p ⟶ q) ∨ (q ⟶ p)"<br />
oops<br />
<br />
end<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_3&diff=151
Relación 3
2013-03-05T14:19:08Z
<p>Isaduatos: </p>
<hr />
<div><source lang="isar"><br />
header {* R3: Deducción natural proposicional *}<br />
<br />
theory R3<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es demostrar cada uno de los ejercicios<br />
usando sólo las reglas básicas de deducción natural de la lógica<br />
proposicional (sin usar el método auto).<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 />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación. *}<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, p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_1a:<br />
assumes 1: "p ⟶ q" and<br />
2: "p"<br />
shows "q"<br />
proof -<br />
show 3: "q" using 1 2 by (rule mp) <br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_1b:<br />
assumes "p ⟶ q"<br />
"p"<br />
shows "q"<br />
proof -<br />
show "q" using assms(1,2) by (rule mp)<br />
qed<br />
<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ q, q ⟶ r, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_2a:<br />
assumes 1:"p ⟶ q" and<br />
2:"q ⟶ r" and<br />
3:"p" <br />
shows "r"<br />
proof -<br />
have 4: "q" using 1 3 by (rule mp)<br />
show 5: "r" using 2 4 by (rule mp) <br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_3a:<br />
assumes 1: "p ⟶ (q ⟶ r)" and<br />
2: "p ⟶ q" and<br />
3: "p" <br />
shows "r"<br />
proof -<br />
have 4: "q ⟶ r" using 1 3 by (rule mp)<br />
have 5: "q" using 2 3 by (rule mp)<br />
show 6: "r" using 4 5 by (rule mp)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
p ⟶ q, q ⟶ r ⊢ p ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_4a:<br />
assumes 1: "p ⟶ q" and<br />
2: "q ⟶ r" <br />
shows "p ⟶ r"<br />
proof -<br />
{assume 3:"p" <br />
have 4: "q" using 1 3 by (rule mp)<br />
have 5: "r" using 2 4 by (rule mp)}<br />
thus "p⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
--"Isabel Duarte"<br />
<br />
lemma ejercicio_5:<br />
assumes 1: "p ⟶ (q ⟶ r)" <br />
shows "q ⟶ (p ⟶ r)"<br />
proof -<br />
{assume 3: "q"<br />
{assume 4: "p"<br />
have "q ⟶ r" using 1 4 ..<br />
hence 5: "r" using 3 ..}<br />
hence 6: "p ⟶ r" by (rule impI)}<br />
thus "q ⟶ (p ⟶ r)" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_6:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ⊢ q ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_7:<br />
assumes "p" <br />
shows "q ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
⊢ p ⟶ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_8:<br />
"p ⟶ (q ⟶ p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_9:<br />
assumes "p ⟶ q" <br />
shows "(q ⟶ r) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_10:<br />
assumes "p ⟶ (q ⟶ (r ⟶ s))" <br />
shows "r ⟶ (q ⟶ (p ⟶ s))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_11:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 12. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_12:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 13. Demostrar<br />
p, q ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros Reina"<br />
<br />
lemma ejercicio_13:<br />
assumes 1:"p" and<br />
2:"q" <br />
shows "p ∧ q"<br />
proof -<br />
show "p ∧ q" using 1 2 by (rule conjI)<br />
qed<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 14. Demostrar<br />
p ∧ q ⊢ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_14:<br />
assumes "p ∧ q" <br />
shows "p"<br />
proof -<br />
show "p" using assms by (rule conjunct1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 15. Demostrar<br />
p ∧ q ⊢ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_15:<br />
assumes "p ∧ q" <br />
shows "q"<br />
proof -<br />
show "q" using assms by (rule conjunct2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 16. Demostrar<br />
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_16:<br />
assumes "p ∧ (q ∧ r)"<br />
shows "(p ∧ q)∧ r"<br />
proof -<br />
have 1: "p" using assms by (rule conjunct1)<br />
have 2: "(q ∧ r)" using assms by (rule conjunct2)<br />
have 3: "q" using 2 by (rule conjunct1)<br />
have 4: "r" using 2 by (rule conjunct2)<br />
have 5: "(p∧q)" using 1 3 by (rule conjI)<br />
show 6: "(p∧q) ∧ r" using 5 4 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 17. Demostrar<br />
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_17:<br />
assumes "(p∧ q) ∧ r" <br />
shows "p ∧ (q∧ r)"<br />
proof -<br />
have 1: "r" using assms by (rule conjunct2)<br />
have 2: "(p∧q)" using assms by (rule conjunct1)<br />
have 3: "p" using 2 by (rule conjunct1)<br />
have 4: "q" using 2 by (rule conjunct2)<br />
have 5: "(q∧r)" using 4 1 by (rule conjI)<br />
show 6: "p∧(q∧r)" using 3 5 by (rule conjI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 18. Demostrar<br />
p ∧ q ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_18:<br />
assumes "p ∧ q" <br />
shows "p ⟶ q"<br />
proof -<br />
have 1: "q" using assms by (rule conjunct2)<br />
show "p⟶ q" using 1 by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 19. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_19:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)" <br />
shows "p ⟶ q ∧ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 20. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_20:<br />
assumes "p ⟶ q ∧ r" <br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 21. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_21:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 22. Demostrar<br />
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_22:<br />
assumes "p ∧ q ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 23. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_23:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 24. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_24:<br />
assumes "p ∧ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ r"<br />
oops<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 25. Demostrar<br />
p ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_25:<br />
assumes "p"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI1)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 26. Demostrar<br />
q ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_26:<br />
assumes "q"<br />
shows "p ∨ q"<br />
proof -<br />
show "p∨q" using assms by (rule disjI2)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 27. Demostrar<br />
p ∨ q ⊢ q ∨ p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_27:<br />
assumes "p ∨ q"<br />
shows "q ∨ p"<br />
proof - <br />
have "p ∨ q" using assms by this<br />
moreover<br />
{ assume 2: "p"<br />
have "q ∨ p" using 2 by (rule disjI2) }<br />
moreover<br />
{ assume 3: "q"<br />
have "q ∨ p" using 3 by (rule disjI1) }<br />
ultimately show "q ∨ p" by (rule disjE) <br />
qed <br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 28. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_28:<br />
assumes "q ⟶ r" <br />
shows "p ∨ q ⟶ p ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 29. Demostrar<br />
p ∨ p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_29:<br />
assumes "p ∨ p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 30. Demostrar<br />
p ⊢ p ∨ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_30:<br />
assumes "p" <br />
shows "p ∨ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 31. Demostrar<br />
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_31:<br />
assumes "p ∨ (q ∨ r)" <br />
shows "(p ∨ q) ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 32. Demostrar<br />
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_32:<br />
assumes "(p ∨ q) ∨ r" <br />
shows "p ∨ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 33. Demostrar<br />
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_33:<br />
assumes "p ∧ (q ∨ r)" <br />
shows "(p ∧ q) ∨ (p ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 34. Demostrar<br />
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_34:<br />
assumes "(p ∧ q) ∨ (p ∧ r)" <br />
shows "p ∧ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 35. Demostrar<br />
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_35:<br />
assumes "p ∨ (q ∧ r)" <br />
shows "(p ∨ q) ∧ (p ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 36. Demostrar<br />
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_36:<br />
assumes "(p ∨ q) ∧ (p ∨ r)"<br />
shows "p ∨ (q ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 37. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_37:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)" <br />
shows "p ∨ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 38. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_38:<br />
assumes "p ∨ q ⟶ r" <br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
oops<br />
<br />
section {* Negaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 39. Demostrar<br />
p ⊢ ¬¬p<br />
------------------------------------------------------------------ *}<br />
-- "Pedro G. Ros Reina"<br />
lemma ejercicio_39:<br />
assumes "p"<br />
shows "¬¬p"<br />
proof -<br />
show "¬¬p" using assms by (rule notnotI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_40:<br />
assumes "¬p" <br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 41. Demostrar<br />
p ⟶ q ⊢ ¬q ⟶ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_41:<br />
assumes "p ⟶ q"<br />
shows "¬q ⟶ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p∨q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_42:<br />
assumes "p∨q"<br />
"¬q" <br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p ∨ q, ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_43:<br />
assumes "p ∨ q"<br />
"¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
p ∨ q ⊢ ¬(¬p ∧ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_44:<br />
assumes "p ∨ q" <br />
shows "¬(¬p ∧ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 45. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_45:<br />
assumes "p ∧ q" <br />
shows "¬(¬p ∨ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 46. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_46:<br />
assumes "¬(p ∨ q)" <br />
shows "¬p ∧ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 47. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_47:<br />
assumes "¬p ∧ ¬q" <br />
shows "¬(p ∨ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 48. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_48:<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 49. Demostrar<br />
⊢ ¬(p ∧ ¬p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_49:<br />
"¬(p ∧ ¬p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 50. Demostrar<br />
p ∧ ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_50:<br />
assumes "p ∧ ¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 51. Demostrar<br />
¬¬p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_51:<br />
assumes "¬¬p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 52. Demostrar<br />
⊢ p ∨ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_52:<br />
"p ∨ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 53. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_53:<br />
"((p ⟶ q) ⟶ p) ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 54. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_54:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 55. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_55:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 56. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_56:<br />
assumes "¬(¬p ∨ ¬q)" <br />
shows "p ∧ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 57. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_57:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 58. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_58:<br />
"(p ⟶ q) ∨ (q ⟶ p)"<br />
oops<br />
<br />
end<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_3&diff=149
Relación 3
2013-03-05T13:57:25Z
<p>Isaduatos: </p>
<hr />
<div><source lang="isar"><br />
header {* R3: Deducción natural proposicional *}<br />
<br />
theory R3<br />
imports Main <br />
begin<br />
<br />
text {*<br />
--------------------------------------------------------------------- <br />
El objetivo de esta relación es demostrar cada uno de los ejercicios<br />
usando sólo las reglas básicas de deducción natural de la lógica<br />
proposicional (sin usar el método auto).<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 />
--------------------------------------------------------------------- <br />
*}<br />
<br />
text {*<br />
Se usarán las reglas notnotI y mt que demostramos a continuación. *}<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, p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_1a:<br />
assumes 1: "p ⟶ q" and<br />
2: "p"<br />
shows "q"<br />
proof -<br />
show 3: "q" using 1 2 by (rule mp) <br />
qed<br />
<br />
-- "Isabel Duarte"<br />
lemma ejercicio_1b:<br />
assumes "p ⟶ q"<br />
"p"<br />
shows "q"<br />
proof -<br />
show "q" using assms(1,2) by (rule mp)<br />
qed<br />
<br />
<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 2. Demostrar<br />
p ⟶ q, q ⟶ r, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_2a:<br />
assumes 1:"p ⟶ q" and<br />
2:"q ⟶ r" and<br />
3:"p" <br />
shows "r"<br />
proof -<br />
have 4: "q" using 1 3 by (rule mp)<br />
show 5: "r" using 2 4 by (rule mp) <br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 3. Demostrar<br />
p ⟶ (q ⟶ r), p ⟶ q, p ⊢ r<br />
------------------------------------------------------------------ *}<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_3a:<br />
assumes 1: "p ⟶ (q ⟶ r)" and<br />
2: "p ⟶ q" and<br />
3: "p" <br />
shows "r"<br />
proof -<br />
have 4: "q ⟶ r" using 1 3 by (rule mp)<br />
have 5: "q" using 2 3 by (rule mp)<br />
show 6: "r" using 4 5 by (rule mp)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 4. Demostrar<br />
p ⟶ q, q ⟶ r ⊢ p ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
<br />
-- "Pedro G. Ros"<br />
lemma ejercicio_4a:<br />
assumes 1: "p ⟶ q" and<br />
2: "q ⟶ r" <br />
shows "p ⟶ r"<br />
proof -<br />
{assume 3:"p" <br />
have 4: "q" using 1 3 by (rule mp)<br />
have 5: "r" using 2 4 by (rule mp)}<br />
thus "p⟶ r" by (rule impI)<br />
qed<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 5. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ q ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_5:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "q ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 6. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ (p ⟶ q) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_6:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 7. Demostrar<br />
p ⊢ q ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_7:<br />
assumes "p" <br />
shows "q ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 8. Demostrar<br />
⊢ p ⟶ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_8:<br />
"p ⟶ (q ⟶ p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 9. Demostrar<br />
p ⟶ q ⊢ (q ⟶ r) ⟶ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_9:<br />
assumes "p ⟶ q" <br />
shows "(q ⟶ r) ⟶ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 10. Demostrar<br />
p ⟶ (q ⟶ (r ⟶ s)) ⊢ r ⟶ (q ⟶ (p ⟶ s))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_10:<br />
assumes "p ⟶ (q ⟶ (r ⟶ s))" <br />
shows "r ⟶ (q ⟶ (p ⟶ s))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 11. Demostrar<br />
⊢ (p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_11:<br />
"(p ⟶ (q ⟶ r)) ⟶ ((p ⟶ q) ⟶ (p ⟶ r))"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 12. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_12:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
section {* Conjunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 13. Demostrar<br />
p, q ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_13:<br />
assumes "p"<br />
"q" <br />
shows "p ∧ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 14. Demostrar<br />
p ∧ q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_14:<br />
assumes "p ∧ q" <br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 15. Demostrar<br />
p ∧ q ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_15:<br />
assumes "p ∧ q" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 16. Demostrar<br />
p ∧ (q ∧ r) ⊢ (p ∧ q) ∧ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_16:<br />
assumes "p ∧ (q ∧ r)"<br />
shows "(p ∧ q) ∧ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 17. Demostrar<br />
(p ∧ q) ∧ r ⊢ p ∧ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_17:<br />
assumes "(p ∧ q) ∧ r" <br />
shows "p ∧ (q ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 18. Demostrar<br />
p ∧ q ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_18:<br />
assumes "p ∧ q" <br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 19. Demostrar<br />
(p ⟶ q) ∧ (p ⟶ r) ⊢ p ⟶ q ∧ r <br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_19:<br />
assumes "(p ⟶ q) ∧ (p ⟶ r)" <br />
shows "p ⟶ q ∧ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 20. Demostrar<br />
p ⟶ q ∧ r ⊢ (p ⟶ q) ∧ (p ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_20:<br />
assumes "p ⟶ q ∧ r" <br />
shows "(p ⟶ q) ∧ (p ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 21. Demostrar<br />
p ⟶ (q ⟶ r) ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_21:<br />
assumes "p ⟶ (q ⟶ r)" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 22. Demostrar<br />
p ∧ q ⟶ r ⊢ p ⟶ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_22:<br />
assumes "p ∧ q ⟶ r" <br />
shows "p ⟶ (q ⟶ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 23. Demostrar<br />
(p ⟶ q) ⟶ r ⊢ p ∧ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_23:<br />
assumes "(p ⟶ q) ⟶ r" <br />
shows "p ∧ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 24. Demostrar<br />
p ∧ (q ⟶ r) ⊢ (p ⟶ q) ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_24:<br />
assumes "p ∧ (q ⟶ r)" <br />
shows "(p ⟶ q) ⟶ r"<br />
oops<br />
<br />
section {* Disyunciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 25. Demostrar<br />
p ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_25:<br />
assumes "p"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 26. Demostrar<br />
q ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_26:<br />
assumes "q"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 27. Demostrar<br />
p ∨ q ⊢ q ∨ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_27:<br />
assumes "p ∨ q"<br />
shows "q ∨ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 28. Demostrar<br />
q ⟶ r ⊢ p ∨ q ⟶ p ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_28:<br />
assumes "q ⟶ r" <br />
shows "p ∨ q ⟶ p ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 29. Demostrar<br />
p ∨ p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_29:<br />
assumes "p ∨ p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 30. Demostrar<br />
p ⊢ p ∨ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_30:<br />
assumes "p" <br />
shows "p ∨ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 31. Demostrar<br />
p ∨ (q ∨ r) ⊢ (p ∨ q) ∨ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_31:<br />
assumes "p ∨ (q ∨ r)" <br />
shows "(p ∨ q) ∨ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 32. Demostrar<br />
(p ∨ q) ∨ r ⊢ p ∨ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_32:<br />
assumes "(p ∨ q) ∨ r" <br />
shows "p ∨ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 33. Demostrar<br />
p ∧ (q ∨ r) ⊢ (p ∧ q) ∨ (p ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_33:<br />
assumes "p ∧ (q ∨ r)" <br />
shows "(p ∧ q) ∨ (p ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 34. Demostrar<br />
(p ∧ q) ∨ (p ∧ r) ⊢ p ∧ (q ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_34:<br />
assumes "(p ∧ q) ∨ (p ∧ r)" <br />
shows "p ∧ (q ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 35. Demostrar<br />
p ∨ (q ∧ r) ⊢ (p ∨ q) ∧ (p ∨ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_35:<br />
assumes "p ∨ (q ∧ r)" <br />
shows "(p ∨ q) ∧ (p ∨ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 36. Demostrar<br />
(p ∨ q) ∧ (p ∨ r) ⊢ p ∨ (q ∧ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_36:<br />
assumes "(p ∨ q) ∧ (p ∨ r)"<br />
shows "p ∨ (q ∧ r)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 37. Demostrar<br />
(p ⟶ r) ∧ (q ⟶ r) ⊢ p ∨ q ⟶ r<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_37:<br />
assumes "(p ⟶ r) ∧ (q ⟶ r)" <br />
shows "p ∨ q ⟶ r"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 38. Demostrar<br />
p ∨ q ⟶ r ⊢ (p ⟶ r) ∧ (q ⟶ r)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_38:<br />
assumes "p ∨ q ⟶ r" <br />
shows "(p ⟶ r) ∧ (q ⟶ r)"<br />
oops<br />
<br />
section {* Negaciones *}<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 39. Demostrar<br />
p ⊢ ¬¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_39:<br />
assumes "p"<br />
shows "¬¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_40:<br />
assumes "¬p" <br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 41. Demostrar<br />
p ⟶ q ⊢ ¬q ⟶ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_41:<br />
assumes "p ⟶ q"<br />
shows "¬q ⟶ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p∨q, ¬q ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_42:<br />
assumes "p∨q"<br />
"¬q" <br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 42. Demostrar<br />
p ∨ q, ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_43:<br />
assumes "p ∨ q"<br />
"¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 40. Demostrar<br />
p ∨ q ⊢ ¬(¬p ∧ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_44:<br />
assumes "p ∨ q" <br />
shows "¬(¬p ∧ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 45. Demostrar<br />
p ∧ q ⊢ ¬(¬p ∨ ¬q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_45:<br />
assumes "p ∧ q" <br />
shows "¬(¬p ∨ ¬q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 46. Demostrar<br />
¬(p ∨ q) ⊢ ¬p ∧ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_46:<br />
assumes "¬(p ∨ q)" <br />
shows "¬p ∧ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 47. Demostrar<br />
¬p ∧ ¬q ⊢ ¬(p ∨ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_47:<br />
assumes "¬p ∧ ¬q" <br />
shows "¬(p ∨ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 48. Demostrar<br />
¬p ∨ ¬q ⊢ ¬(p ∧ q)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_48:<br />
assumes "¬p ∨ ¬q"<br />
shows "¬(p ∧ q)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 49. Demostrar<br />
⊢ ¬(p ∧ ¬p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_49:<br />
"¬(p ∧ ¬p)"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 50. Demostrar<br />
p ∧ ¬p ⊢ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_50:<br />
assumes "p ∧ ¬p" <br />
shows "q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 51. Demostrar<br />
¬¬p ⊢ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_51:<br />
assumes "¬¬p"<br />
shows "p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 52. Demostrar<br />
⊢ p ∨ ¬p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_52:<br />
"p ∨ ¬p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 53. Demostrar<br />
⊢ ((p ⟶ q) ⟶ p) ⟶ p<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_53:<br />
"((p ⟶ q) ⟶ p) ⟶ p"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 54. Demostrar<br />
¬q ⟶ ¬p ⊢ p ⟶ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_54:<br />
assumes "¬q ⟶ ¬p"<br />
shows "p ⟶ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 55. Demostrar<br />
¬(¬p ∧ ¬q) ⊢ p ∨ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_55:<br />
assumes "¬(¬p ∧ ¬q)"<br />
shows "p ∨ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 56. Demostrar<br />
¬(¬p ∨ ¬q) ⊢ p ∧ q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_56:<br />
assumes "¬(¬p ∨ ¬q)" <br />
shows "p ∧ q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 57. Demostrar<br />
¬(p ∧ q) ⊢ ¬p ∨ ¬q<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_57:<br />
assumes "¬(p ∧ q)"<br />
shows "¬p ∨ ¬q"<br />
oops<br />
<br />
text {* --------------------------------------------------------------- <br />
Ejercicio 58. Demostrar<br />
⊢ (p ⟶ q) ∨ (q ⟶ p)<br />
------------------------------------------------------------------ *}<br />
<br />
lemma ejercicio_58:<br />
"(p ⟶ q) ∨ (q ⟶ p)"<br />
oops<br />
<br />
end<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_2&diff=108
Relación 2
2013-02-22T11:15:40Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
-- SintaxisSemanticaProp.hs<br />
-- Lógica proposicional: Sintaxis y semántica<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module SintaxisSemantica where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Gramática de fórmulas prosicionales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir los siguientes tipos de datos:<br />
-- * SímboloProposicional para representar los símbolos de proposiciones<br />
-- * Prop para representar las fórmulas proposicionales usando los<br />
-- constructores Atom, Neg, Conj, Disj, Impl y Equi para las fórmulas<br />
-- atómicas, negaciones, conjunciones, implicaciones y equivalencias,<br />
-- respectivamente. <br />
-- ---------------------------------------------------------------------<br />
<br />
type SímboloProposicional = String<br />
<br />
data Prop = Atom SímboloProposicional<br />
| Neg Prop <br />
| Conj Prop Prop <br />
| Disj Prop Prop <br />
| Impl Prop Prop <br />
| Equi Prop Prop <br />
deriving (Eq,Ord)<br />
<br />
instance Show Prop where<br />
show (Atom p) = p<br />
show (Neg p) = "no " ++ show p<br />
show (Conj p q) = "(" ++ show p ++ " /\\ " ++ show q ++ ")"<br />
show (Disj p q) = "(" ++ show p ++ " \\/ " ++ show q ++ ")"<br />
show (Impl p q) = "(" ++ show p ++ " --> " ++ show q ++ ")"<br />
show (Equi p q) = "(" ++ show p ++ " <--> " ++ show q ++ ")"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir las siguientes fórmulas proposicionales<br />
-- atómicas: p, p1, p2, q, r, s, t y u.<br />
-- ---------------------------------------------------------------------<br />
<br />
p, p1, p2, q, r, s, t, u :: Prop<br />
p = Atom "p"<br />
p1 = Atom "p1"<br />
p2 = Atom "p2"<br />
q = Atom "q"<br />
r = Atom "r"<br />
s = Atom "s"<br />
t = Atom "t"<br />
u = Atom "u"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- no :: Prop -> Prop<br />
-- tal que (no f) es la negación de f.<br />
-- ---------------------------------------------------------------------<br />
<br />
no :: Prop -> Prop<br />
no = Neg<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir los siguientes operadores<br />
-- (/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
-- tales que<br />
-- f /\ g es la conjunción de f y g<br />
-- f \/ g es la disyunción de f y g<br />
-- f --> g es la implicación de f a g<br />
-- f <--> g es la equivalencia entre f y g<br />
-- ---------------------------------------------------------------------<br />
<br />
infixr 5 \/<br />
infixr 4 /\<br />
infixr 3 --><br />
infixr 2 <--><br />
(/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
(/\) = Conj<br />
(\/) = Disj<br />
(-->) = Impl<br />
(<-->) = Equi<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- símbolosPropFórm :: Prop -> [Prop]<br />
-- tal que (símbolosPropFórm f) es el conjunto formado por todos los<br />
-- símbolos proposicionales que aparecen en f. Por ejemplo,<br />
-- símbolosPropFórm (p /\ q --> p) ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropForm :: Prop -> [Prop]<br />
simbolosPropForm (Atom p) = [(Atom p)]<br />
simbolosPropForm (Neg p) = simbolosPropForm p<br />
simbolosPropForm (Conj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Disj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Impl p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Equi p q) = simbolosPropForm p `union` simbolosPropForm q<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir el tipo de datos Interpretación para<br />
-- representar las interpretaciones como listas de fórmulas atómicas.<br />
-- ---------------------------------------------------------------------<br />
<br />
type Interpretación = [Prop]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Significado de una fórmula en una interpretación --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- significado :: Prop -> Interpretación -> Bool<br />
-- tal que (significado f i) es el significado de f en i. Por ejemplo,<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [r] ==> False<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [p,r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro G. Ros<br />
significado :: Prop -> Interpretacion -> Bool<br />
significado (Atom p) a = elem (Atom p) a<br />
significado (Neg p) a = not (significado p a)<br />
significado (Conj p q) a= (significado p a)&& (significado q a)<br />
significado (Disj p q) a =(significado p a)|| (significado q a)<br />
significado (Impl p q) a = if (significado p a) then (significado q a)==<br />
True else True<br />
significado (Equi p q) a = (significado (Impl p q) a )&&(significado (Impl q p)) a <br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- subconjuntos :: [a] -> [[a]]<br />
-- tal que (subconjuntos x) es la lista de los subconjuntos de x. Por<br />
-- ejmplo, <br />
-- subconjuntos "abc" ==> ["abc","ab","ac","a","bc","b","c",""]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
subconjuntos :: [a] -> [[a]]<br />
subconjuntos [] = [[]]<br />
subconjuntos (x:xs) = [x:ys | ys <- subconjuntos xs] ++ subconjuntos xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesFórm :: Prop -> [Interpretación]<br />
-- tal que (interpretacionesFórm f) es la lista de todas las<br />
-- interpretaciones de f. Por ejemplo, <br />
-- interpretacionesFórm (p /\ q --> p) ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesForm :: Prop -> [Interpretación]<br />
interpretacionesForm p = subconjuntos (simbolosPropForm p)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloFórmula :: Interpretación -> Prop -> Bool<br />
-- tal que (esModeloFórmula i f) se verifica si i es un modelo de f. Por<br />
-- ejemplo, <br />
-- esModeloFórmula [r] ((p \/ q) /\ ((no q) \/ r)) ==> False<br />
-- esModeloFórmula [p,r] ((p \/ q) /\ ((no q) \/ r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
esModeloFórmula :: Interpretación -> Prop -> Bool<br />
esModeloFórmula i (Atom p) = significado (Atom p) i<br />
esModeloFórmula i (Conj a b)= significado (Conj a b) i<br />
esModeloFórmula i (Disj a b) = esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Impl a b)=esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Equi a b)=(esModeloFórmula i (Impl a b))&&(esModeloFórmula i (Impl b a))<br />
esModeloFórmula i (Neg b)=not(esModeloFórmula i b)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosFórmula :: Prop -> [Interpretación]<br />
-- tal que (modelosFórmula f) es la lista de todas las interpretaciones<br />
-- de f que son modelo de F. Por ejemplo,<br />
-- modelosFórmula ((p \/ q) /\ ((no q) \/ r)) <br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
modelosFórmula :: Prop -> [Interpretación]<br />
modelosFórmula f = [x|x<-(interpretacionesForm f),esModeloFórmula x f]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Fórmulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- esVálida :: Prop -> Bool<br />
-- tal que (esVálida f) se verifica si f es válida. Por ejemplo,<br />
-- esVálida (p --> p) ==> True<br />
-- esVálida (p --> q) ==> False<br />
-- esVálida ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esVálida :: Prop -> Bool<br />
esVálida f = modelosFormula f == interpretacionesForm f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esInsatisfacible :: Prop -> Bool<br />
-- tal que (esInsatisfacible f) se verifica si f es insatisfacible. Por<br />
-- ejemplo, <br />
-- esInsatisfacible (p /\ (no p)) ==> True<br />
-- esInsatisfacible ((p --> q) /\ (q --> r)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esInsatisfacible :: Prop -> Bool<br />
esInsatisfacible f = modelosFormula f == []<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esSatisfacible :: Prop -> Bool<br />
-- tal que (esSatisfacible f) se verifica si f es satisfacible. Por<br />
-- ejemplo, <br />
-- esSatisfacible (p /\ (no p)) ==> False<br />
-- esSatisfacible ((p --> q) /\ (q --> r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Reme Sillero<br />
<br />
esSatisfacible :: Prop -> Bool<br />
esSatisfacible f = modelosFormula f /= []<br />
<br />
-- Isabel Duarte<br />
esSatisfacible2 :: Prop -> Bool<br />
esSatisfacible2 f = not (esInsatisfacible f)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- uniónGeneral :: Eq a => [[a]] -> [a]<br />
-- tal que (uniónGeneral x) es la unión de los conjuntos de la lista de<br />
-- conjuntos x. Por ejemplo,<br />
-- uniónGeneral [] ==> []<br />
-- uniónGeneral [[1]] ==> [1]<br />
-- uniónGeneral [[1],[1,2],[2,3]] ==> [1,2,3]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
unionGeneral :: Eq a => [[a]] -> [a]<br />
unionGeneral [] = []<br />
unionGeneral (x:xs) = x `union` unionGeneral xs <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- símbolosPropConj :: [Prop] -> [Prop]<br />
-- tal que (símbolosPropConj s) es el conjunto de los símbolos<br />
-- proposiciones de s. Por ejemplo,<br />
-- símbolosPropConj [p /\ q --> r, p --> s] ==> [p,q,r,s]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropConj :: [Prop] -> [Prop]<br />
simbolosPropConj s = unionGeneral [simbolosPropForm x|x<-s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (interpretacionesConjunto s) es la lista de las<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjunto [p --> q, q --> r]<br />
-- ==> [[p,q,r],[p,q],[p,r],[p],[q,r],[q],[r],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
interpretacionesConjunto s = subconjuntos (simbolosPropConj s)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
-- tal que (esModeloConjunto i s) se verifica si i es modelo de s. Por<br />
-- ejemplo, <br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> True<br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
esModeloConjunto i s = and [ esModeloFórmula i x | x <- s] <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- modelosConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (modelosConjunto s) es la lista de modelos del conjunto<br />
-- s. Por ejemplo,<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> [[p,q,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
modelosConjunto :: [Prop] -> [Interpretación]<br />
modelosConjunto s = [ x | x <- (interpretacionesConjunto s), esModeloConjunto x s]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos consistentes e inconsistentes de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConsistente :: [Prop] -> Bool<br />
-- tal que (esConsistente s) se verifica si s es consistente. Por<br />
-- ejemplo, <br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> True<br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsistente :: [Prop] -> Bool<br />
esConsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esInconsistente :: [Prop] -> Bool<br />
-- tal que (esInconsistente s) se verifica si s es inconsistente. Por<br />
-- ejemplo, <br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> False<br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esInconsistente :: [Prop] -> Bool<br />
esInconsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuencia :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuencia s f) se verifica si f es consecuencia de<br />
-- s. Por ejemplo,<br />
-- esConsecuencia [p --> q, q --> r] (p --> r) ==> True<br />
-- esConsecuencia [p] (p /\ q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuencia :: [Prop] -> Prop -> Bool<br />
esConsecuencia s f = undefined<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_2&diff=107
Relación 2
2013-02-22T11:15:17Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
-- SintaxisSemanticaProp.hs<br />
-- Lógica proposicional: Sintaxis y semántica<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module SintaxisSemantica where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Gramática de fórmulas prosicionales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir los siguientes tipos de datos:<br />
-- * SímboloProposicional para representar los símbolos de proposiciones<br />
-- * Prop para representar las fórmulas proposicionales usando los<br />
-- constructores Atom, Neg, Conj, Disj, Impl y Equi para las fórmulas<br />
-- atómicas, negaciones, conjunciones, implicaciones y equivalencias,<br />
-- respectivamente. <br />
-- ---------------------------------------------------------------------<br />
<br />
type SímboloProposicional = String<br />
<br />
data Prop = Atom SímboloProposicional<br />
| Neg Prop <br />
| Conj Prop Prop <br />
| Disj Prop Prop <br />
| Impl Prop Prop <br />
| Equi Prop Prop <br />
deriving (Eq,Ord)<br />
<br />
instance Show Prop where<br />
show (Atom p) = p<br />
show (Neg p) = "no " ++ show p<br />
show (Conj p q) = "(" ++ show p ++ " /\\ " ++ show q ++ ")"<br />
show (Disj p q) = "(" ++ show p ++ " \\/ " ++ show q ++ ")"<br />
show (Impl p q) = "(" ++ show p ++ " --> " ++ show q ++ ")"<br />
show (Equi p q) = "(" ++ show p ++ " <--> " ++ show q ++ ")"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir las siguientes fórmulas proposicionales<br />
-- atómicas: p, p1, p2, q, r, s, t y u.<br />
-- ---------------------------------------------------------------------<br />
<br />
p, p1, p2, q, r, s, t, u :: Prop<br />
p = Atom "p"<br />
p1 = Atom "p1"<br />
p2 = Atom "p2"<br />
q = Atom "q"<br />
r = Atom "r"<br />
s = Atom "s"<br />
t = Atom "t"<br />
u = Atom "u"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- no :: Prop -> Prop<br />
-- tal que (no f) es la negación de f.<br />
-- ---------------------------------------------------------------------<br />
<br />
no :: Prop -> Prop<br />
no = Neg<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir los siguientes operadores<br />
-- (/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
-- tales que<br />
-- f /\ g es la conjunción de f y g<br />
-- f \/ g es la disyunción de f y g<br />
-- f --> g es la implicación de f a g<br />
-- f <--> g es la equivalencia entre f y g<br />
-- ---------------------------------------------------------------------<br />
<br />
infixr 5 \/<br />
infixr 4 /\<br />
infixr 3 --><br />
infixr 2 <--><br />
(/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
(/\) = Conj<br />
(\/) = Disj<br />
(-->) = Impl<br />
(<-->) = Equi<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- símbolosPropFórm :: Prop -> [Prop]<br />
-- tal que (símbolosPropFórm f) es el conjunto formado por todos los<br />
-- símbolos proposicionales que aparecen en f. Por ejemplo,<br />
-- símbolosPropFórm (p /\ q --> p) ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropForm :: Prop -> [Prop]<br />
simbolosPropForm (Atom p) = [(Atom p)]<br />
simbolosPropForm (Neg p) = simbolosPropForm p<br />
simbolosPropForm (Conj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Disj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Impl p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Equi p q) = simbolosPropForm p `union` simbolosPropForm q<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir el tipo de datos Interpretación para<br />
-- representar las interpretaciones como listas de fórmulas atómicas.<br />
-- ---------------------------------------------------------------------<br />
<br />
type Interpretación = [Prop]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Significado de una fórmula en una interpretación --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- significado :: Prop -> Interpretación -> Bool<br />
-- tal que (significado f i) es el significado de f en i. Por ejemplo,<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [r] ==> False<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [p,r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro G. Ros<br />
significado :: Prop -> Interpretacion -> Bool<br />
significado (Atom p) a = elem (Atom p) a<br />
significado (Neg p) a = not (significado p a)<br />
significado (Conj p q) a= (significado p a)&& (significado q a)<br />
significado (Disj p q) a =(significado p a)|| (significado q a)<br />
significado (Impl p q) a = if (significado p a) then (significado q a)==<br />
True else True<br />
significado (Equi p q) a = (significado (Impl p q) a )&&(significado (Impl q p)) a <br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- subconjuntos :: [a] -> [[a]]<br />
-- tal que (subconjuntos x) es la lista de los subconjuntos de x. Por<br />
-- ejmplo, <br />
-- subconjuntos "abc" ==> ["abc","ab","ac","a","bc","b","c",""]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
subconjuntos :: [a] -> [[a]]<br />
subconjuntos [] = [[]]<br />
subconjuntos (x:xs) = [x:ys | ys <- subconjuntos xs] ++ subconjuntos xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesFórm :: Prop -> [Interpretación]<br />
-- tal que (interpretacionesFórm f) es la lista de todas las<br />
-- interpretaciones de f. Por ejemplo, <br />
-- interpretacionesFórm (p /\ q --> p) ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesForm :: Prop -> [Interpretación]<br />
interpretacionesForm p = subconjuntos (simbolosPropForm p)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloFórmula :: Interpretación -> Prop -> Bool<br />
-- tal que (esModeloFórmula i f) se verifica si i es un modelo de f. Por<br />
-- ejemplo, <br />
-- esModeloFórmula [r] ((p \/ q) /\ ((no q) \/ r)) ==> False<br />
-- esModeloFórmula [p,r] ((p \/ q) /\ ((no q) \/ r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
esModeloFórmula :: Interpretación -> Prop -> Bool<br />
esModeloFórmula i (Atom p) = significado (Atom p) i<br />
esModeloFórmula i (Conj a b)= significado (Conj a b) i<br />
esModeloFórmula i (Disj a b) = esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Impl a b)=esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Equi a b)=(esModeloFórmula i (Impl a b))&&(esModeloFórmula i (Impl b a))<br />
esModeloFórmula i (Neg b)=not(esModeloFórmula i b)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosFórmula :: Prop -> [Interpretación]<br />
-- tal que (modelosFórmula f) es la lista de todas las interpretaciones<br />
-- de f que son modelo de F. Por ejemplo,<br />
-- modelosFórmula ((p \/ q) /\ ((no q) \/ r)) <br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
modelosFórmula :: Prop -> [Interpretación]<br />
modelosFórmula f = [x|x<-(interpretacionesForm f),esModeloFórmula x f]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Fórmulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- esVálida :: Prop -> Bool<br />
-- tal que (esVálida f) se verifica si f es válida. Por ejemplo,<br />
-- esVálida (p --> p) ==> True<br />
-- esVálida (p --> q) ==> False<br />
-- esVálida ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esVálida :: Prop -> Bool<br />
esVálida f = modelosFormula f == interpretacionesForm f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esInsatisfacible :: Prop -> Bool<br />
-- tal que (esInsatisfacible f) se verifica si f es insatisfacible. Por<br />
-- ejemplo, <br />
-- esInsatisfacible (p /\ (no p)) ==> True<br />
-- esInsatisfacible ((p --> q) /\ (q --> r)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esInsatisfacible :: Prop -> Bool<br />
esInsatisfacible f = modelosFormula f == []<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esSatisfacible :: Prop -> Bool<br />
-- tal que (esSatisfacible f) se verifica si f es satisfacible. Por<br />
-- ejemplo, <br />
-- esSatisfacible (p /\ (no p)) ==> False<br />
-- esSatisfacible ((p --> q) /\ (q --> r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Reme Sillero<br />
<br />
esSatisfacible :: Prop -> Bool<br />
esSatisfacible f = modelosFormula f /= []<br />
<br />
-- Isabel Duarte<br />
esSatisfacible2 :: Prop -> Bool<br />
esSatisfacible2 f = not (esInsatisfacible f)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- uniónGeneral :: Eq a => [[a]] -> [a]<br />
-- tal que (uniónGeneral x) es la unión de los conjuntos de la lista de<br />
-- conjuntos x. Por ejemplo,<br />
-- uniónGeneral [] ==> []<br />
-- uniónGeneral [[1]] ==> [1]<br />
-- uniónGeneral [[1],[1,2],[2,3]] ==> [1,2,3]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
unionGeneral :: Eq a => [[a]] -> [a]<br />
unionGeneral [] = []<br />
unionGeneral (x:xs) = x `union` unionGeneral xs <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- símbolosPropConj :: [Prop] -> [Prop]<br />
-- tal que (símbolosPropConj s) es el conjunto de los símbolos<br />
-- proposiciones de s. Por ejemplo,<br />
-- símbolosPropConj [p /\ q --> r, p --> s] ==> [p,q,r,s]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropConj :: [Prop] -> [Prop]<br />
simbolosPropConj s = unionGeneral [simbolosPropForm x|x<-s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (interpretacionesConjunto s) es la lista de las<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjunto [p --> q, q --> r]<br />
-- ==> [[p,q,r],[p,q],[p,r],[p],[q,r],[q],[r],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
interpretacionesConjunto s = subconjuntos (simbolosPropConj s)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
-- tal que (esModeloConjunto i s) se verifica si i es modelo de s. Por<br />
-- ejemplo, <br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> True<br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
esModeloConjunto i s = and [ esModeloFórmula i x | x <- s] <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- modelosConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (modelosConjunto s) es la lista de modelos del conjunto<br />
-- s. Por ejemplo,<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> [[p,q,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
modelosConjunto :: [Prop] -> [Interpretación]<br />
modelosConjunto s = [ x | x <- (interpretacionesConjunto s), esModeloConjunto x s]<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos consistentes e inconsistentes de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConsistente :: [Prop] -> Bool<br />
-- tal que (esConsistente s) se verifica si s es consistente. Por<br />
-- ejemplo, <br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> True<br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsistente :: [Prop] -> Bool<br />
esConsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esInconsistente :: [Prop] -> Bool<br />
-- tal que (esInconsistente s) se verifica si s es inconsistente. Por<br />
-- ejemplo, <br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> False<br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esInconsistente :: [Prop] -> Bool<br />
esInconsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuencia :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuencia s f) se verifica si f es consecuencia de<br />
-- s. Por ejemplo,<br />
-- esConsecuencia [p --> q, q --> r] (p --> r) ==> True<br />
-- esConsecuencia [p] (p /\ q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuencia :: [Prop] -> Prop -> Bool<br />
esConsecuencia s f = undefined<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_2&diff=106
Relación 2
2013-02-22T11:12:57Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
-- SintaxisSemanticaProp.hs<br />
-- Lógica proposicional: Sintaxis y semántica<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module SintaxisSemantica where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Gramática de fórmulas prosicionales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir los siguientes tipos de datos:<br />
-- * SímboloProposicional para representar los símbolos de proposiciones<br />
-- * Prop para representar las fórmulas proposicionales usando los<br />
-- constructores Atom, Neg, Conj, Disj, Impl y Equi para las fórmulas<br />
-- atómicas, negaciones, conjunciones, implicaciones y equivalencias,<br />
-- respectivamente. <br />
-- ---------------------------------------------------------------------<br />
<br />
type SímboloProposicional = String<br />
<br />
data Prop = Atom SímboloProposicional<br />
| Neg Prop <br />
| Conj Prop Prop <br />
| Disj Prop Prop <br />
| Impl Prop Prop <br />
| Equi Prop Prop <br />
deriving (Eq,Ord)<br />
<br />
instance Show Prop where<br />
show (Atom p) = p<br />
show (Neg p) = "no " ++ show p<br />
show (Conj p q) = "(" ++ show p ++ " /\\ " ++ show q ++ ")"<br />
show (Disj p q) = "(" ++ show p ++ " \\/ " ++ show q ++ ")"<br />
show (Impl p q) = "(" ++ show p ++ " --> " ++ show q ++ ")"<br />
show (Equi p q) = "(" ++ show p ++ " <--> " ++ show q ++ ")"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir las siguientes fórmulas proposicionales<br />
-- atómicas: p, p1, p2, q, r, s, t y u.<br />
-- ---------------------------------------------------------------------<br />
<br />
p, p1, p2, q, r, s, t, u :: Prop<br />
p = Atom "p"<br />
p1 = Atom "p1"<br />
p2 = Atom "p2"<br />
q = Atom "q"<br />
r = Atom "r"<br />
s = Atom "s"<br />
t = Atom "t"<br />
u = Atom "u"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- no :: Prop -> Prop<br />
-- tal que (no f) es la negación de f.<br />
-- ---------------------------------------------------------------------<br />
<br />
no :: Prop -> Prop<br />
no = Neg<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir los siguientes operadores<br />
-- (/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
-- tales que<br />
-- f /\ g es la conjunción de f y g<br />
-- f \/ g es la disyunción de f y g<br />
-- f --> g es la implicación de f a g<br />
-- f <--> g es la equivalencia entre f y g<br />
-- ---------------------------------------------------------------------<br />
<br />
infixr 5 \/<br />
infixr 4 /\<br />
infixr 3 --><br />
infixr 2 <--><br />
(/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
(/\) = Conj<br />
(\/) = Disj<br />
(-->) = Impl<br />
(<-->) = Equi<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- símbolosPropFórm :: Prop -> [Prop]<br />
-- tal que (símbolosPropFórm f) es el conjunto formado por todos los<br />
-- símbolos proposicionales que aparecen en f. Por ejemplo,<br />
-- símbolosPropFórm (p /\ q --> p) ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropForm :: Prop -> [Prop]<br />
simbolosPropForm (Atom p) = [(Atom p)]<br />
simbolosPropForm (Neg p) = simbolosPropForm p<br />
simbolosPropForm (Conj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Disj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Impl p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Equi p q) = simbolosPropForm p `union` simbolosPropForm q<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir el tipo de datos Interpretación para<br />
-- representar las interpretaciones como listas de fórmulas atómicas.<br />
-- ---------------------------------------------------------------------<br />
<br />
type Interpretación = [Prop]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Significado de una fórmula en una interpretación --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- significado :: Prop -> Interpretación -> Bool<br />
-- tal que (significado f i) es el significado de f en i. Por ejemplo,<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [r] ==> False<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [p,r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro G. Ros<br />
significado :: Prop -> Interpretacion -> Bool<br />
significado (Atom p) a = elem (Atom p) a<br />
significado (Neg p) a = not (significado p a)<br />
significado (Conj p q) a= (significado p a)&& (significado q a)<br />
significado (Disj p q) a =(significado p a)|| (significado q a)<br />
significado (Impl p q) a = if (significado p a) then (significado q a)==<br />
True else True<br />
significado (Equi p q) a = (significado (Impl p q) a )&&(significado (Impl q p)) a <br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- subconjuntos :: [a] -> [[a]]<br />
-- tal que (subconjuntos x) es la lista de los subconjuntos de x. Por<br />
-- ejmplo, <br />
-- subconjuntos "abc" ==> ["abc","ab","ac","a","bc","b","c",""]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
subconjuntos :: [a] -> [[a]]<br />
subconjuntos [] = [[]]<br />
subconjuntos (x:xs) = [x:ys | ys <- subconjuntos xs] ++ subconjuntos xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesFórm :: Prop -> [Interpretación]<br />
-- tal que (interpretacionesFórm f) es la lista de todas las<br />
-- interpretaciones de f. Por ejemplo, <br />
-- interpretacionesFórm (p /\ q --> p) ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesForm :: Prop -> [Interpretación]<br />
interpretacionesForm p = subconjuntos (simbolosPropForm p)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloFórmula :: Interpretación -> Prop -> Bool<br />
-- tal que (esModeloFórmula i f) se verifica si i es un modelo de f. Por<br />
-- ejemplo, <br />
-- esModeloFórmula [r] ((p \/ q) /\ ((no q) \/ r)) ==> False<br />
-- esModeloFórmula [p,r] ((p \/ q) /\ ((no q) \/ r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
esModeloFórmula :: Interpretación -> Prop -> Bool<br />
esModeloFórmula i (Atom p) = significado (Atom p) i<br />
esModeloFórmula i (Conj a b)= significado (Conj a b) i<br />
esModeloFórmula i (Disj a b) = esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Impl a b)=esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Equi a b)=(esModeloFórmula i (Impl a b))&&(esModeloFórmula i (Impl b a))<br />
esModeloFórmula i (Neg b)=not(esModeloFórmula i b)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosFórmula :: Prop -> [Interpretación]<br />
-- tal que (modelosFórmula f) es la lista de todas las interpretaciones<br />
-- de f que son modelo de F. Por ejemplo,<br />
-- modelosFórmula ((p \/ q) /\ ((no q) \/ r)) <br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
modelosFórmula :: Prop -> [Interpretación]<br />
modelosFórmula f = [x|x<-(interpretacionesForm f),esModeloFórmula x f]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Fórmulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- esVálida :: Prop -> Bool<br />
-- tal que (esVálida f) se verifica si f es válida. Por ejemplo,<br />
-- esVálida (p --> p) ==> True<br />
-- esVálida (p --> q) ==> False<br />
-- esVálida ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esVálida :: Prop -> Bool<br />
esVálida f = modelosFormula f == interpretacionesForm f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esInsatisfacible :: Prop -> Bool<br />
-- tal que (esInsatisfacible f) se verifica si f es insatisfacible. Por<br />
-- ejemplo, <br />
-- esInsatisfacible (p /\ (no p)) ==> True<br />
-- esInsatisfacible ((p --> q) /\ (q --> r)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esInsatisfacible :: Prop -> Bool<br />
esInsatisfacible f = modelosFormula f == []<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esSatisfacible :: Prop -> Bool<br />
-- tal que (esSatisfacible f) se verifica si f es satisfacible. Por<br />
-- ejemplo, <br />
-- esSatisfacible (p /\ (no p)) ==> False<br />
-- esSatisfacible ((p --> q) /\ (q --> r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Reme Sillero<br />
<br />
esSatisfacible :: Prop -> Bool<br />
esSatisfacible f = modelosFormula f /= []<br />
<br />
-- Isabel Duarte<br />
esSatisfacible2 :: Prop -> Bool<br />
esSatisfacible2 f = not (esInsatisfacible f)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- uniónGeneral :: Eq a => [[a]] -> [a]<br />
-- tal que (uniónGeneral x) es la unión de los conjuntos de la lista de<br />
-- conjuntos x. Por ejemplo,<br />
-- uniónGeneral [] ==> []<br />
-- uniónGeneral [[1]] ==> [1]<br />
-- uniónGeneral [[1],[1,2],[2,3]] ==> [1,2,3]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
unionGeneral :: Eq a => [[a]] -> [a]<br />
unionGeneral [] = []<br />
unionGeneral (x:xs) = x `union` unionGeneral xs <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- símbolosPropConj :: [Prop] -> [Prop]<br />
-- tal que (símbolosPropConj s) es el conjunto de los símbolos<br />
-- proposiciones de s. Por ejemplo,<br />
-- símbolosPropConj [p /\ q --> r, p --> s] ==> [p,q,r,s]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropConj :: [Prop] -> [Prop]<br />
simbolosPropConj s = unionGeneral [simbolosPropForm x|x<-s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (interpretacionesConjunto s) es la lista de las<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjunto [p --> q, q --> r]<br />
-- ==> [[p,q,r],[p,q],[p,r],[p],[q,r],[q],[r],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
interpretacionesConjunto s = subconjuntos (simbolosPropConj s)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
-- tal que (esModeloConjunto i s) se verifica si i es modelo de s. Por<br />
-- ejemplo, <br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> True<br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
--Isabel Duarte<br />
esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
esModeloConjunto i s = and [ esModeloFórmula i x | x <- s] <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- modelosConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (modelosConjunto s) es la lista de modelos del conjunto<br />
-- s. Por ejemplo,<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> [[p,q,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosConjunto :: [Prop] -> [Interpretación]<br />
modelosConjunto s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos consistentes e inconsistentes de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConsistente :: [Prop] -> Bool<br />
-- tal que (esConsistente s) se verifica si s es consistente. Por<br />
-- ejemplo, <br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> True<br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsistente :: [Prop] -> Bool<br />
esConsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esInconsistente :: [Prop] -> Bool<br />
-- tal que (esInconsistente s) se verifica si s es inconsistente. Por<br />
-- ejemplo, <br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> False<br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esInconsistente :: [Prop] -> Bool<br />
esInconsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuencia :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuencia s f) se verifica si f es consecuencia de<br />
-- s. Por ejemplo,<br />
-- esConsecuencia [p --> q, q --> r] (p --> r) ==> True<br />
-- esConsecuencia [p] (p /\ q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuencia :: [Prop] -> Prop -> Bool<br />
esConsecuencia s f = undefined<br />
</source></div>
Isaduatos
https://www.glc.us.es/~jalonso/LMF2013/index.php?title=Relaci%C3%B3n_2&diff=105
Relación 2
2013-02-22T11:08:31Z
<p>Isaduatos: </p>
<hr />
<div><source lang="haskell"><br />
-- SintaxisSemanticaProp.hs<br />
-- Lógica proposicional: Sintaxis y semántica<br />
-- José A. Alonso Jiménez <jalonso@us,es><br />
-- ---------------------------------------------------------------------<br />
<br />
module SintaxisSemantica where<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Librerías auxiliares --<br />
-- ---------------------------------------------------------------------<br />
<br />
import Data.List <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Gramática de fórmulas prosicionales --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 1: Definir los siguientes tipos de datos:<br />
-- * SímboloProposicional para representar los símbolos de proposiciones<br />
-- * Prop para representar las fórmulas proposicionales usando los<br />
-- constructores Atom, Neg, Conj, Disj, Impl y Equi para las fórmulas<br />
-- atómicas, negaciones, conjunciones, implicaciones y equivalencias,<br />
-- respectivamente. <br />
-- ---------------------------------------------------------------------<br />
<br />
type SímboloProposicional = String<br />
<br />
data Prop = Atom SímboloProposicional<br />
| Neg Prop <br />
| Conj Prop Prop <br />
| Disj Prop Prop <br />
| Impl Prop Prop <br />
| Equi Prop Prop <br />
deriving (Eq,Ord)<br />
<br />
instance Show Prop where<br />
show (Atom p) = p<br />
show (Neg p) = "no " ++ show p<br />
show (Conj p q) = "(" ++ show p ++ " /\\ " ++ show q ++ ")"<br />
show (Disj p q) = "(" ++ show p ++ " \\/ " ++ show q ++ ")"<br />
show (Impl p q) = "(" ++ show p ++ " --> " ++ show q ++ ")"<br />
show (Equi p q) = "(" ++ show p ++ " <--> " ++ show q ++ ")"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 2: Definir las siguientes fórmulas proposicionales<br />
-- atómicas: p, p1, p2, q, r, s, t y u.<br />
-- ---------------------------------------------------------------------<br />
<br />
p, p1, p2, q, r, s, t, u :: Prop<br />
p = Atom "p"<br />
p1 = Atom "p1"<br />
p2 = Atom "p2"<br />
q = Atom "q"<br />
r = Atom "r"<br />
s = Atom "s"<br />
t = Atom "t"<br />
u = Atom "u"<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 3: Definir la función<br />
-- no :: Prop -> Prop<br />
-- tal que (no f) es la negación de f.<br />
-- ---------------------------------------------------------------------<br />
<br />
no :: Prop -> Prop<br />
no = Neg<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 4: Definir los siguientes operadores<br />
-- (/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
-- tales que<br />
-- f /\ g es la conjunción de f y g<br />
-- f \/ g es la disyunción de f y g<br />
-- f --> g es la implicación de f a g<br />
-- f <--> g es la equivalencia entre f y g<br />
-- ---------------------------------------------------------------------<br />
<br />
infixr 5 \/<br />
infixr 4 /\<br />
infixr 3 --><br />
infixr 2 <--><br />
(/\), (\/), (-->), (<-->) :: Prop -> Prop -> Prop<br />
(/\) = Conj<br />
(\/) = Disj<br />
(-->) = Impl<br />
(<-->) = Equi<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 5: Definir la función<br />
-- símbolosPropFórm :: Prop -> [Prop]<br />
-- tal que (símbolosPropFórm f) es el conjunto formado por todos los<br />
-- símbolos proposicionales que aparecen en f. Por ejemplo,<br />
-- símbolosPropFórm (p /\ q --> p) ==> [p,q]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropForm :: Prop -> [Prop]<br />
simbolosPropForm (Atom p) = [(Atom p)]<br />
simbolosPropForm (Neg p) = simbolosPropForm p<br />
simbolosPropForm (Conj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Disj p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Impl p q) = simbolosPropForm p `union` simbolosPropForm q<br />
simbolosPropForm (Equi p q) = simbolosPropForm p `union` simbolosPropForm q<br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 6: Definir el tipo de datos Interpretación para<br />
-- representar las interpretaciones como listas de fórmulas atómicas.<br />
-- ---------------------------------------------------------------------<br />
<br />
type Interpretación = [Prop]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Significado de una fórmula en una interpretación --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 7: Definir la función<br />
-- significado :: Prop -> Interpretación -> Bool<br />
-- tal que (significado f i) es el significado de f en i. Por ejemplo,<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [r] ==> False<br />
-- significado ((p \/ q) /\ ((no q) \/ r)) [p,r] ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Pedro G. Ros<br />
significado :: Prop -> Interpretacion -> Bool<br />
significado (Atom p) a = elem (Atom p) a<br />
significado (Neg p) a = not (significado p a)<br />
significado (Conj p q) a= (significado p a)&& (significado q a)<br />
significado (Disj p q) a =(significado p a)|| (significado q a)<br />
significado (Impl p q) a = if (significado p a) then (significado q a)==<br />
True else True<br />
significado (Equi p q) a = (significado (Impl p q) a )&&(significado (Impl q p)) a <br />
<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de una fórmula --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 8: Definir la función<br />
-- subconjuntos :: [a] -> [[a]]<br />
-- tal que (subconjuntos x) es la lista de los subconjuntos de x. Por<br />
-- ejmplo, <br />
-- subconjuntos "abc" ==> ["abc","ab","ac","a","bc","b","c",""]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
subconjuntos :: [a] -> [[a]]<br />
subconjuntos [] = [[]]<br />
subconjuntos (x:xs) = [x:ys | ys <- subconjuntos xs] ++ subconjuntos xs<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 9: Definir la función<br />
-- interpretacionesFórm :: Prop -> [Interpretación]<br />
-- tal que (interpretacionesFórm f) es la lista de todas las<br />
-- interpretaciones de f. Por ejemplo, <br />
-- interpretacionesFórm (p /\ q --> p) ==> [[p,q],[p],[q],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesForm :: Prop -> [Interpretación]<br />
interpretacionesForm p = subconjuntos (simbolosPropForm p)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 10: Definir la función<br />
-- esModeloFórmula :: Interpretación -> Prop -> Bool<br />
-- tal que (esModeloFórmula i f) se verifica si i es un modelo de f. Por<br />
-- ejemplo, <br />
-- esModeloFórmula [r] ((p \/ q) /\ ((no q) \/ r)) ==> False<br />
-- esModeloFórmula [p,r] ((p \/ q) /\ ((no q) \/ r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
esModeloFórmula :: Interpretación -> Prop -> Bool<br />
esModeloFórmula i (Atom p) = significado (Atom p) i<br />
esModeloFórmula i (Conj a b)= significado (Conj a b) i<br />
esModeloFórmula i (Disj a b) = esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Impl a b)=esModeloFórmula i (Conj a b)<br />
esModeloFórmula i (Equi a b)=(esModeloFórmula i (Impl a b))&&(esModeloFórmula i (Impl b a))<br />
esModeloFórmula i (Neg b)=not(esModeloFórmula i b)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 11: Definir la función<br />
-- modelosFórmula :: Prop -> [Interpretación]<br />
-- tal que (modelosFórmula f) es la lista de todas las interpretaciones<br />
-- de f que son modelo de F. Por ejemplo,<br />
-- modelosFórmula ((p \/ q) /\ ((no q) \/ r)) <br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
--Pedro G. Ros<br />
modelosFórmula :: Prop -> [Interpretación]<br />
modelosFórmula f = [x|x<-(interpretacionesForm f),esModeloFórmula x f]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Fórmulas válidas, satisfacibles e insatisfacibles --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 12: Definir la función<br />
-- esVálida :: Prop -> Bool<br />
-- tal que (esVálida f) se verifica si f es válida. Por ejemplo,<br />
-- esVálida (p --> p) ==> True<br />
-- esVálida (p --> q) ==> False<br />
-- esVálida ((p --> q) \/ (q --> p)) ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esVálida :: Prop -> Bool<br />
esVálida f = modelosFormula f == interpretacionesForm f<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 13: Definir la función<br />
-- esInsatisfacible :: Prop -> Bool<br />
-- tal que (esInsatisfacible f) se verifica si f es insatisfacible. Por<br />
-- ejemplo, <br />
-- esInsatisfacible (p /\ (no p)) ==> True<br />
-- esInsatisfacible ((p --> q) /\ (q --> r)) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
esInsatisfacible :: Prop -> Bool<br />
esInsatisfacible f = modelosFormula f == []<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 14: Definir la función<br />
-- esSatisfacible :: Prop -> Bool<br />
-- tal que (esSatisfacible f) se verifica si f es satisfacible. Por<br />
-- ejemplo, <br />
-- esSatisfacible (p /\ (no p)) ==> False<br />
-- esSatisfacible ((p --> q) /\ (q --> r)) ==> True<br />
-- ---------------------------------------------------------------------<br />
-- Reme Sillero<br />
<br />
esSatisfacible :: Prop -> Bool<br />
esSatisfacible f = modelosFormula f /= []<br />
<br />
-- Isabel Duarte<br />
esSatisfacible2 :: Prop -> Bool<br />
esSatisfacible2 f = not (esInsatisfacible f)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Símbolos proposicionales de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 15: Definir la función<br />
-- uniónGeneral :: Eq a => [[a]] -> [a]<br />
-- tal que (uniónGeneral x) es la unión de los conjuntos de la lista de<br />
-- conjuntos x. Por ejemplo,<br />
-- uniónGeneral [] ==> []<br />
-- uniónGeneral [[1]] ==> [1]<br />
-- uniónGeneral [[1],[1,2],[2,3]] ==> [1,2,3]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
unionGeneral :: Eq a => [[a]] -> [a]<br />
unionGeneral [] = []<br />
unionGeneral (x:xs) = x `union` unionGeneral xs <br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 16: Definir la función<br />
-- símbolosPropConj :: [Prop] -> [Prop]<br />
-- tal que (símbolosPropConj s) es el conjunto de los símbolos<br />
-- proposiciones de s. Por ejemplo,<br />
-- símbolosPropConj [p /\ q --> r, p --> s] ==> [p,q,r,s]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Antonio Molero<br />
<br />
simbolosPropConj :: [Prop] -> [Prop]<br />
simbolosPropConj s = unionGeneral [simbolosPropForm x|x<-s]<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Interpretaciones de un conjunto de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 17: Definir la función<br />
-- interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (interpretacionesConjunto s) es la lista de las<br />
-- interpretaciones de s. Por ejemplo,<br />
-- interpretacionesConjunto [p --> q, q --> r]<br />
-- ==> [[p,q,r],[p,q],[p,r],[p],[q,r],[q],[r],[]]<br />
-- ---------------------------------------------------------------------<br />
<br />
-- Reme Sillero<br />
<br />
interpretacionesConjunto :: [Prop] -> [Interpretación]<br />
interpretacionesConjunto s = subconjuntos (simbolosPropConj s)<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Modelos de conjuntos de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 18: Definir la función<br />
-- esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
-- tal que (esModeloConjunto i s) se verifica si i es modelo de s. Por<br />
-- ejemplo, <br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> True<br />
-- esModeloConjunto [p,r] [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esModeloConjunto :: Interpretación -> [Prop] -> Bool<br />
esModeloConjunto i s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 19: Definir la función<br />
-- modelosConjunto :: [Prop] -> [Interpretación]<br />
-- tal que (modelosConjunto s) es la lista de modelos del conjunto<br />
-- s. Por ejemplo,<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), q --> r]<br />
-- ==> [[p,q,r],[p,r],[p],[q,r]]<br />
-- modelosConjunto [(p \/ q) /\ ((no q) \/ r), r --> q]<br />
-- ==> [[p,q,r],[p],[q,r]]<br />
-- ---------------------------------------------------------------------<br />
<br />
modelosConjunto :: [Prop] -> [Interpretación]<br />
modelosConjunto s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Conjuntos consistentes e inconsistentes de fórmulas --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 20: Definir la función<br />
-- esConsistente :: [Prop] -> Bool<br />
-- tal que (esConsistente s) se verifica si s es consistente. Por<br />
-- ejemplo, <br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> True<br />
-- esConsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsistente :: [Prop] -> Bool<br />
esConsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 21: Definir la función<br />
-- esInconsistente :: [Prop] -> Bool<br />
-- tal que (esInconsistente s) se verifica si s es inconsistente. Por<br />
-- ejemplo, <br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r] <br />
-- ==> False<br />
-- esInconsistente [(p \/ q) /\ ((no q) \/ r), p --> r, no r] <br />
-- ==> True<br />
-- ---------------------------------------------------------------------<br />
<br />
esInconsistente :: [Prop] -> Bool<br />
esInconsistente s = undefined<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Consecuencia lógica --<br />
-- ---------------------------------------------------------------------<br />
<br />
-- ---------------------------------------------------------------------<br />
-- Ejercicio 22: Definir la función<br />
-- esConsecuencia :: [Prop] -> Prop -> Bool<br />
-- tal que (esConsecuencia s f) se verifica si f es consecuencia de<br />
-- s. Por ejemplo,<br />
-- esConsecuencia [p --> q, q --> r] (p --> r) ==> True<br />
-- esConsecuencia [p] (p /\ q) ==> False<br />
-- ---------------------------------------------------------------------<br />
<br />
esConsecuencia :: [Prop] -> Prop -> Bool<br />
esConsecuencia s f = undefined<br />
</source></div>
Isaduatos