Relación 10 - Historial de revisiones

Pedperroj en 17:52 22 may 2013

2013-05-22T17:52:41Z

Alebalher en 09:45 20 may 2013

2013-05-20T09:45:09Z

Mirnunolm en 17:15 15 may 2013

2013-05-15T17:15:34Z

Isaduatos en 11:10 15 may 2013

2013-05-15T11:10:01Z

Isaduatos en 11:07 15 may 2013

2013-05-15T11:07:45Z

Isaduatos en 11:06 15 may 2013

2013-05-15T11:06:58Z

Josconbel en 09:43 10 may 2013

2013-05-10T09:43:30Z

Mjoseh: Página creada con ' -- Clausulas.hs -- Cláusulas. -- --------------------------------------------------------------------- module Clausulas where -- -------------------...'

2013-05-02T09:05:02Z

Página creada con '<source lang = "haskell"> -- Clausulas.hs -- Cláusulas. -- --------------------------------------------------------------------- module Clausulas where -- -------------------...'

Página nueva

<source lang = "haskell">
-- Clausulas.hs
-- Cláusulas.
-- ---------------------------------------------------------------------

module Clausulas where

-- ---------------------------------------------------------------------
-- Librería suxiliares --
-- ---------------------------------------------------------------------

import SintaxisSemantica
import FormasNormales
import Data.List

-- ---------------------------------------------------------------------
-- Cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 1: Definir el tipo de datos Cláusula como una lista de
-- literales.
-- ---------------------------------------------------------------------

type Cláusula = [Literal]

-- ---------------------------------------------------------------------
-- Ejercicio 2: Definir la función
-- cláusula :: Prop -> Cláusula
-- tal que (cláusula f) es la cláusula de la fórmula-clausal f. Por
-- ejemplo,
-- cláusula p ==> [p]
-- cláusula (no p) ==> [no p]
-- cláusula (((no p) \/ r) \/ ((no p) \/ q)) ==> [q,r,no p]
-- ---------------------------------------------------------------------

cláusula :: Prop -> Cláusula
cláusula f = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 3: Definir la función
-- cláusulasFNC :: Prop -> [Cláusula]
-- tal que (cláusulasFNC f) es el conjunto de cláusulas de la fórmula en
-- forma normal conjuntiva f. Por ejmplo,
-- cláusulasFNC (p /\ ((no q) \/ r))
-- ==> [[p],[r, no q]]
-- cláusulasFNC (((no p) \/ q) /\ ((no p) \/ (no r)))
-- ==> [[q, no p],[no p,no r]]
-- ---------------------------------------------------------------------

cláusulasFNC :: Prop -> [Cláusula]
cláusulasFNC = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 4: Definir la función
-- cláusulas :: Prop -> [Cláusula]
-- tal que (cláusulas f) es un conjunto de cláusulas equivalente a
-- f. Por ejemplo,
-- cláusulas (p /\ (q --> r))
-- ==> [[p],[r,no q]]
-- cláusulas (no (p /\ (q --> r)))
-- ==> [[q,no p],[no p,no r]]
-- cláusulas (no(p <--> r))
-- ==> [[p,r],[p,no p],[r,no r],[no p,no r]]
-- ---------------------------------------------------------------------

cláusulas :: Prop -> [Cláusula]
cláusulas f = undefined

-- ---------------------------------------------------------------------
-- Cláusulas de un conjunto de fórmulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 5: Definir la función
-- cláusulasConjunto :: [Prop] -> [Cláusula]
-- tal que (cláusulasConjunto s) es un conjunto de cláusulas equivalente
-- a s. Por ejemplo,
-- cláusulasConjunto [p --> q, q --> r] ==> [[q,no p],[r,no q]]
-- cláusulasConjunto [p --> q, q <--> p] ==> [[q,no p],[p,no q]]
-- ---------------------------------------------------------------------

cláusulasConjunto :: [Prop] -> [Cláusula]
cláusulasConjunto s = undefined

-- ---------------------------------------------------------------------
-- Símbolos proposicionales de una cláusula --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 6: Definir la función
-- símbolosProposicionalesCláusula :: Cláusula -> [Prop]
-- tal que (símbolosProposicionalesCláusula c) es el conjunto de los
-- símbolos proposicionales de c. Por ejemplo,
-- símbolosProposicionalesCláusula [p, q, no p] ==> [p,q]
-- ---------------------------------------------------------------------

símbolosProposicionalesCláusula :: Cláusula -> [Prop]
símbolosProposicionalesCláusula = undefined

-- ---------------------------------------------------------------------
-- Símbolos proposicionales de un conjunto de cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 7: Definir la función
-- símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]
-- tal que (símbolosProposicionalesConjuntoCláusula s) es el conjunto de los
-- símbolos proposicionales de s. Por ejemplo,
-- símbolosProposicionalesConjuntoCláusula [[p, q],[no q, r]]
-- ==> [p,q,r]
-- ---------------------------------------------------------------------

símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]
símbolosProposicionalesConjuntoCláusula s = undefined

-- ---------------------------------------------------------------------
-- Interpretaciones de una cláusula --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 8: Definir la función
-- interpretacionesCláusula :: Cláusula -> [Interpretación]
-- tal que (interpretacionesCláusula c) es el conjunto de
-- interpretaciones de c. Por ejemplo,
-- interpretacionesCláusula [p, q, no p] ==> [[p,q],[p],[q],[]]
-- interpretacionesCláusula [] ==> [[]]
-- ---------------------------------------------------------------------

interpretacionesCláusula :: Cláusula -> [Interpretación]
interpretacionesCláusula c = undefined

-- ---------------------------------------------------------------------
-- Interpretaciones de un conjunto de cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 9: Definir la función
-- interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]
-- tal que (interpretacionesConjuntoCláusula s) es el conjunto de
-- interpretaciones de s. Por ejemplo,
-- interpretacionesConjuntoCláusula [[p, no q],[no p, q]]
-- ==> [[p,q],[p],[q],[]]
-- interpretacionesConjuntoCláusula []
-- ==> [[]]
-- ---------------------------------------------------------------------

interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]
interpretacionesConjuntoCláusula c = undefined

-- ---------------------------------------------------------------------
-- Modelos de cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 10: Definir la función
-- esModeloLiteral :: Interpretación -> Literal -> Bool
-- tal que (esModeloLiteral i l) se verifica si i es modelo de l. Por
-- ejemplo,
-- esModeloLiteral [p,r] p ==> True
-- esModeloLiteral [p,r] q ==> False
-- esModeloLiteral [p,r] (no p) ==> False
-- esModeloLiteral [p,r] (no q) ==> True
-- ---------------------------------------------------------------------

esModeloLiteral :: Interpretación -> Literal -> Bool
esModeloLiteral = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11: Definir la función
-- esModeloCláusula :: Interpretación -> Cláusula -> Bool
-- tal que (esModeloCláusula i c) se verifica si i es modelo de c . Por
-- ejemplo,
-- esModeloCláusula [p,r] [p, q] ==> True
-- esModeloCláusula [r] [p, no q] ==> True
-- esModeloCláusula [q,r] [p, no q] ==> False
-- esModeloCláusula [q,r] [] ==> False
-- ---------------------------------------------------------------------

esModeloCláusula :: Interpretación -> Cláusula -> Bool
esModeloCláusula i c = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 12: Definir la función
-- modelosCláusula :: Cláusula -> [Interpretación]
-- tal que (modelosCláusula c) es la lista de los modelos de c. Por
-- ejemplo,
-- modelosCláusula [no p, q] ==> [[p,q],[q],[]]
-- modelosCláusula [no p, p] ==> [[p],[]]
-- modelosCláusula [] ==> []
-- ---------------------------------------------------------------------

modelosCláusula :: Cláusula -> [Interpretación]
modelosCláusula c = undefined

-- ---------------------------------------------------------------------
-- Modelos de conjuntos de cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 13: Definir la función
-- esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool
-- tal que (esModeloConjuntoCláusulas i c) se verifica si i es modelo de
-- c. Por ejemplo,
-- esModeloConjuntoCláusulas [p,r] [[p, no q], [r]] ==> True
-- esModeloConjuntoCláusulas [p] [[p, no q], [r]] ==> False
-- esModeloConjuntoCláusulas [p] [] ==> True
-- ---------------------------------------------------------------------

esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool
esModeloConjuntoCláusulas i s = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 14: Definir la función
-- modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]
-- tal que (modelosConjuntoCláusulas s) es la lista de los modelos de
-- s. Por ejemplo,
-- modelosConjuntoCláusulas [[no p, q], [no q, p]]
-- ==> [[p,q],[]]
-- modelosConjuntoCláusulas [[no p, q], [p], [no q]]
-- ==> []
-- modelosConjuntoCláusulas [[p, no p, q]]
-- ==> [[p,q],[p],[q],[]]
-- ---------------------------------------------------------------------

modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]
modelosConjuntoCláusulas s = undefined

-- ---------------------------------------------------------------------
-- Cláusulas válidas, satisfacibles e insatisfacibles --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 15: Definir la función
-- esCláusulaVálida :: Cláusula -> Bool
-- tal que (esCláusulaVálida c) se verifica si la cláusula c es
-- válida. Por ejemplo,
-- esCláusulaVálida [p, q, no p] ==> True
-- esCláusulaVálida [p, q, no r] ==> False
-- esCláusulaVálida [] ==> False
-- ---------------------------------------------------------------------

esCláusulaVálida :: Cláusula -> Bool
esCláusulaVálida c = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 16: Definir la función
-- esCláusulaInsatisfacible :: Cláusula -> Bool
-- tal que (esCláusulaInsatisfacible c) se verifica si la cláusula c es
-- insatisfacible. Por ejemplo,
-- esCláusulaInsatisfacible [p, q, no p] ==> False
-- esCláusulaInsatisfacible [p, q, no r] ==> False
-- esCláusulaInsatisfacible [] ==> True
-- ---------------------------------------------------------------------

esCláusulaInsatisfacible :: Cláusula -> Bool
esCláusulaInsatisfacible c = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 17: Definir la función
-- esCláusulaSatisfacible :: Cláusula -> Bool
-- tal que (esCláusulaSatisfacible c) se verifica si la cláusula c es
-- satisfacible. Por ejemplo,
-- esCláusulaSatisfacible [p, q, no p] ==> True
-- esCláusulaSatisfacible [p, q, no r] ==> True
-- esCláusulaSatisfacible [] ==> False
-- ---------------------------------------------------------------------

esCláusulaSatisfacible :: Cláusula -> Bool
esCláusulaSatisfacible c = undefined

-- ---------------------------------------------------------------------
-- Conjuntos válidos, consistentes e inconsistentes de cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 18: Definir la función
-- esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool
-- tal que (esConjuntoVálidoDeCláusulas s) se verifica si el conjunto de
-- cláusulas s es válido. Por ejemplo,
-- esConjuntoVálidoDeCláusulas [[no p, q], [no q, p]] ==> False
-- esConjuntoVálidoDeCláusulas [[no p, p], [no q, q]] ==> True
-- esConjuntoVálidoDeCláusulas [] ==> True
-- ---------------------------------------------------------------------

esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool
esConjuntoVálidoDeCláusulas s = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 19: Definir la función
-- esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool
-- tal que (esConjuntoConsistenteDeCláusulas s) se verifica si el
-- conjunto de cláusulas s es consistente. Por ejemplo,
-- esConjuntoConsistenteDeCláusulas [[no p, q], [no q, p]] ==> True
-- esConjuntoConsistenteDeCláusulas [[no p, p], [no q, q]] ==> True
-- esConjuntoConsistenteDeCláusulas [] ==> True
-- ---------------------------------------------------------------------

esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool
esConjuntoConsistenteDeCláusulas s = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 20: Definir la función
-- esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool
-- tal que (esConjuntoInconsistenteDeCláusulas s) se verifica si el
-- conjunto de cláusulas s es consistente. Por ejemplo,
-- esConjuntoInconsistenteDeCláusulas [[no p,q],[no q,p]] ==> False
-- esConjuntoInconsistenteDeCláusulas [[no p],[p]] ==> True
-- ---------------------------------------------------------------------

esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool
esConjuntoInconsistenteDeCláusulas s = undefined

-- ---------------------------------------------------------------------
-- Validez de fórmulas mediante cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 21: Definir la función
-- esVálidaPorCláusulas :: Prop -> Bool
-- tal que (esVálidaPorCláusulas f) se verifica si el conjunto de
-- cláusulas de f es válido. Por ejemplo,
-- esVálidaPorCláusulas (p --> q) ==> False
-- esVálidaPorCláusulas (p --> p) ==> True
-- esVálidaPorCláusulas ((p --> q) \/ (q --> p)) ==> True
-- ---------------------------------------------------------------------

esVálidaPorCláusulas :: Prop -> Bool
esVálidaPorCláusulas f = undefined

-- ---------------------------------------------------------------------
-- Consecuencia mediante cláusulas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 22: Definir la función
-- esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool
-- tal que (esConsecuenciaEntreCláusulas s1 s2) se verifica si todos los
-- modelos de s1 son modelos de s2. Por ejemplo,
-- esConsecuenciaEntreCláusulas [[no p,q],[no q,r]] [[no p,r]]
-- ==> True
-- esConsecuenciaEntreCláusulas [[p]] [[p],[q]]
-- ==> False
-- ---------------------------------------------------------------------

esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool
esConsecuenciaEntreCláusulas s1 s2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 23: Definir la función
-- esConsecuenciaPorCláusulas1 :: [Prop] -> Prop -> Bool
-- tal que (esConsecuenciaPorCláusulas s f) se verifica si las cláusulas
-- de f son consecuencias de las de s. Por ejemplo,
-- esConsecuenciaPorCláusulas [(p --> q), (q --> r)] (p --> r)
-- ==> True
-- esConsecuenciaPorCláusulas [p] (p /\ q)
-- ==> False
-- ---------------------------------------------------------------------

esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool
esConsecuenciaPorCláusulas s f = undefined

</source>

@@ Línea 107: / Línea 107: @@
 -- ---------------------------------------------------------------------
-símbolosProposicionalesCláusula :: Cláusula -> [Prop]
+--Isabel Duarte
-símbolosProposicionalesCláusula = undefined
+simbolosProposicionalesClausula :: Clausula -> [Prop]
 -- ---------------------------------------------------------------------

@@ Línea 162: / Línea 162: @@
 --Isabel Duarte
 interpretacionesConjuntoClausula :: [Cláusula] -> [Interpretación]
-interpretacionesConjuntoCláusula c =
+interpretacionesConjuntoClausula c =
    subconjuntos (simbolosProposicionalesConjuntoClausula c)

@@ Línea 91: / Línea 91: @@
 -- ---------------------------------------------------------------------
-cláusulasConjunto :: [Prop] -> [Cláusula]
+--Isabel Duarte
-cláusulasConjunto s = undefined
+clausulasConjunto :: [Prop] -> [Cláusula]
 -- ---------------------------------------------------------------------
@@ Línea 122: / Línea 123: @@
 -- ---------------------------------------------------------------------
-símbolosProposicionalesConjuntoCláusula :: [Cláusula] -> [Prop]
+--Isabel Duarte
-símbolosProposicionalesConjuntoCláusula s = undefined
+simbolosProposicionalesConjuntoClausula :: [Cláusula] -> [Prop]
 -- ---------------------------------------------------------------------
@@ Línea 138: / Línea 141: @@
 -- ---------------------------------------------------------------------
-interpretacionesCláusula :: Cláusula -> [Interpretación]
+--Isabel Duarte
-interpretacionesCláusula c = undefined
+interpretacionesClausula :: Cláusula -> [Interpretación]
 -- ---------------------------------------------------------------------
@@ Línea 156: / Línea 160: @@
 -- ---------------------------------------------------------------------
-interpretacionesConjuntoCláusula :: [Cláusula] -> [Interpretación]
+--Isabel Duarte
-interpretacionesConjuntoCláusula c = undefined
+interpretacionesConjuntoClausula :: [Cláusula] -> [Interpretación]
 -- ---------------------------------------------------------------------
@@ Línea 174: / Línea 180: @@
 -- ---------------------------------------------------------------------
-esModeloLiteral :: Interpretación -> Literal -> Bool
+--Isabel Duarte
-esModeloLiteral = undefined
+esModeloLiteral :: Interpretacion -> Literal -> Bool
 -- ---------------------------------------------------------------------
@@ Línea 188: / Línea 196: @@
 -- ---------------------------------------------------------------------
-esModeloCláusula :: Interpretación -> Cláusula -> Bool
+--Isabel Duarte
-esModeloCláusula i c = undefined
+esModeloClausula :: Interpretacion -> Clausula -> Bool
 -- ---------------------------------------------------------------------
@@ Línea 201: / Línea 211: @@
 -- ---------------------------------------------------------------------
-modelosCláusula :: Cláusula -> [Interpretación]
+--Isabel Duarte
-modelosCláusula c = undefined
+modelosClausula :: Clausula -> [Interpretacion]
 -- ---------------------------------------------------------------------

@@ Línea 383: / Línea 383: @@
 --    ==> False
 -- ---------------------------------------------------------------------
 esConsecuenciaEntreCláusulas :: [Cláusula] -> [Cláusula] -> Bool
-esConsecuenciaEntreCláusulas s1 s2 = undefined
+esConsecuenciaEntreClausulas s1 s2 = null [k | k <- interpretacionesConjuntoClausula (s1++s2)
 -- ---------------------------------------------------------------------
@@ Línea 402: / Línea 405: @@
 esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool
 esConsecuenciaPorCláusulas s f = esConjuntoInconsistenteDeClausulas (clausulasConjunto((Neg f):s))
 </source>

@@ Línea 283: / Línea 283: @@
 --    esCláusulaInsatisfacible []            ==>  True
 -- ---------------------------------------------------------------------
 esCláusulaInsatisfacible :: Cláusula -> Bool
-esCláusulaInsatisfacible c = undefined
+esCláusulaInsatisfacible c = null c
 -- ---------------------------------------------------------------------
@@ Línea 296: / Línea 298: @@
 --    esCláusulaSatisfacible []  ==>  False
 -- ---------------------------------------------------------------------
 esCláusulaSatisfacible :: Cláusula -> Bool
-esCláusulaSatisfacible c = undefined
+esCláusulaSatisfacible c = not (null c)
 -- ---------------------------------------------------------------------
@@ Línea 313: / Línea 317: @@
 --    esConjuntoVálidoDeCláusulas []                      ==>  True
 -- ---------------------------------------------------------------------
 esConjuntoVálidoDeCláusulas :: [Cláusula] -> Bool
-esConjuntoVálidoDeCláusulas s = undefined
+esConjuntoVálidoDeCláusulas s = and [ esClausulaValida c|c<-s]
 -- ---------------------------------------------------------------------
@@ Línea 326: / Línea 332: @@
 --    esConjuntoConsistenteDeCláusulas []                      ==>  True
 -- ---------------------------------------------------------------------
 esConjuntoConsistenteDeCláusulas :: [Cláusula] -> Bool
-esConjuntoConsistenteDeCláusulas s = undefined
+esConjuntoConsistenteDeCláusulas s = not( null (modeloConjuntoClausulas s))
 -- ---------------------------------------------------------------------
@@ Línea 338: / Línea 346: @@
 --    esConjuntoInconsistenteDeCláusulas [[no p],[p]]         ==>  True
 -- ---------------------------------------------------------------------
 esConjuntoInconsistenteDeCláusulas :: [Cláusula] -> Bool
-esConjuntoInconsistenteDeCláusulas s = undefined
+esConjuntoInconsistenteDeCláusulas s = null (modeloConjuntoClausulas s))
 -- ---------------------------------------------------------------------
@@ Línea 357: / Línea 367: @@
 esVálidaPorCláusulas :: Prop -> Bool
-esVálidaPorCláusulas f = undefined
+esVálidaPorCláusulas f = esConjuntoValidoDeClausulas (clausulas f)
 -- ---------------------------------------------------------------------
@@ Línea 387: / Línea 397: @@
 --    ==> False
 -- ---------------------------------------------------------------------
 esConsecuenciaPorCláusulas :: [Prop] -> Prop -> Bool
-esConsecuenciaPorCláusulas s f = undefined
+esConsecuenciaPorCláusulas s f = esConjuntoInconsistenteDeClausulas (clausulasConjunto((Neg f):s))
 </source>

@@ Línea 231: / Línea 231: @@
 -- ---------------------------------------------------------------------
-esModeloConjuntoCláusulas :: Interpretación -> [Cláusula] -> Bool
+--Miriam Núñez-Romero
-esModeloConjuntoCláusulas i s = undefined
 -- ---------------------------------------------------------------------
@@ Línea 247: / Línea 249: @@
 -- ---------------------------------------------------------------------
-modelosConjuntoCláusulas :: [Cláusula] -> [Interpretación]
+--Miriam Núñez-Romero
-modelosConjuntoCláusulas s = undefined
 -- ---------------------------------------------------------------------
@@ Línea 264: / Línea 269: @@
 -- ---------------------------------------------------------------------
-esCláusulaVálida :: Cláusula -> Bool
+--Miriam Núñez-Romero
-esCláusulaVálida c = undefined
 -- ---------------------------------------------------------------------

@@ Línea 34: / Línea 34: @@
 --    cláusula (((no p) \/ r) \/ ((no p) \/ q))  ==>  [q,r,no p]
 -- ---------------------------------------------------------------------
 -- ---------------------------------------------------------------------
@@ Línea 49: / Línea 53: @@
 -- ---------------------------------------------------------------------
-cláusulasFNC :: Prop -> [Cláusula]
+--José M Contreras
-cláusulasFNC = undefined
 -- ---------------------------------------------------------------------
@@ Línea 65: / Línea 73: @@
 -- ---------------------------------------------------------------------
-cláusulas :: Prop -> [Cláusula]
+--José M Contreras
-cláusulas f = undefined
 -- ---------------------------------------------------------------------