{"id":3321,"date":"2013-05-10T16:18:10","date_gmt":"2013-05-10T16:18:10","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3321"},"modified":"2013-05-10T16:18:10","modified_gmt":"2013-05-10T16:18:10","slug":"lmf2013-clausulas-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/lmf2013-clausulas-en-haskell\/","title":{"rendered":"LMF2013: Cl\u00e1usulas en Haskell"},"content":{"rendered":"

En la clase de hoy del curso de L\u00f3gica matem\u00e1tica y fundamentos<\/a> (de 3\u00ba de Grado en Matem\u00e1ticas) se ha comentado las soluciones de los ejercicios sobre la implementaci\u00f3n en Haskell de las cl\u00e1usulas.<\/p>\n

Las soluciones de los ejercicios se muestran a continuaci\u00f3n. En los ejercicios se usa el m\u00f3dulo SintaxisSemantica desarrollado en la clase del d\u00eda 27 de febrero<\/a> y el m\u00f3dulo FormasNormales desarrollado en la clase del d\u00eda 8 de mayo<\/a>.
\n<\/p>\n

\r\nmodule Clausulas where\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Librer\u00eda suxiliares                                                --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport SintaxisSemantica\r\nimport FormasNormales\r\nimport Data.List\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Clausulas                                                          --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1: Definir el tipo de datos Clausula como una lista de\r\n-- literales. \r\n-- ---------------------------------------------------------------------\r\n\r\ntype Clausula = [Literal]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2: Definir la funci\u00f3n\r\n--    clausula :: Prop -> Clausula\r\n-- tal que (clausula f) es la clausula de la f\u00f3rmula-clausal f. Por\r\n-- ejemplo, \r\n--    clausula p                                 ==>  [p]\r\n--    clausula (no p)                            ==>  [no p]\r\n--    clausula (((no p) \\\/ r) \\\/ ((no p) \\\/ q))  ==>  [q,r,no p]\r\n-- ---------------------------------------------------------------------\r\n\r\nclausula :: Prop -> Clausula\r\nclausula f \r\n    | literal f     = [f]\r\nclausula (Disj f g) = sort ((clausula f) `union` (clausula g))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3: Definir la funci\u00f3n\r\n--    clausulasFNC :: Prop -> [Clausula]\r\n-- tal que (clausulasFNC f) es el conjunto de clausulas de la f\u00f3rmula en\r\n-- forma normal conjuntiva f. Por ejmplo,\r\n--    clausulasFNC (p \/\\ ((no q) \\\/ r))\r\n--    ==> [[p],[r, no q]]\r\n--    clausulasFNC (((no p) \\\/ q) \/\\ ((no p) \\\/ (no r)))\r\n--    ==> [[q, no p],[no p,no r]]\r\n-- ---------------------------------------------------------------------\r\n\r\nclausulasFNC :: Prop -> [Clausula]\r\nclausulasFNC (Conj f g) = \r\n    (clausulasFNC f) `union`  (clausulasFNC g) \r\nclausulasFNC f =\r\n    [clausula f]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4: Definir la funci\u00f3n\r\n--    clausulas :: Prop -> [Clausula]\r\n-- tal que (clausulas f) es un conjunto de clausulas equivalente a\r\n-- f. Por ejemplo,\r\n--    clausulas (p \/\\ (q --> r))       \r\n--    ==> [[p],[r,no q]]\r\n--    clausulas (no (p \/\\ (q --> r)))  \r\n--    ==> [[q,no p],[no p,no r]]\r\n--    clausulas (no(p <--> r))         \r\n--    ==> [[p,r],[p,no p],[r,no r],[no p,no r]]\r\n-- ---------------------------------------------------------------------\r\n\r\nclausulas :: Prop -> [Clausula]\r\nclausulas f =\r\n    clausulasFNC (formaNormalConjuntiva f)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Clausulas de un conjunto de f\u00f3rmulas                               --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5: Definir la funci\u00f3n\r\n--    clausulasConjunto :: [Prop] -> [Clausula]\r\n-- tal que (clausulasConjunto s) es un conjunto de clausulas equivalente\r\n-- a s. Por ejemplo,\r\n--    clausulasConjunto [p --> q, q --> r]   ==>  [[q,no p],[r,no q]]\r\n--    clausulasConjunto [p --> q, q <--> p]  ==>  [[q,no p],[p,no q]]\r\n-- ---------------------------------------------------------------------\r\n\r\nclausulasConjunto :: [Prop] -> [Clausula]\r\nclausulasConjunto s =\r\n    unionGeneral [clausulas f | f <- s]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- S\u00edmbolos proposicionales de una clausula                           --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6: Definir la funci\u00f3n\r\n--    s\u00edmbolosProposicionalesClausula :: Clausula -> [Prop]\r\n-- tal que (s\u00edmbolosProposicionalesClausula c) es el conjunto de los\r\n-- s\u00edmbolos proposicionales de c. Por ejemplo,\r\n--    s\u00edmbolosProposicionalesClausula [p, q, no p]  ==>  [p,q]\r\n-- ---------------------------------------------------------------------\r\n\r\ns\u00edmbolosProposicionalesClausula :: Clausula -> [Prop]\r\ns\u00edmbolosProposicionalesClausula = simbolosPropConj\r\n\r\n-- ---------------------------------------------------------------------\r\n-- S\u00edmbolos proposicionales de un conjunto de clausulas               --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7: Definir la funci\u00f3n\r\n--    s\u00edmbolosProposicionalesConjuntoClausula :: [Clausula] -> [Prop]\r\n-- tal que (s\u00edmbolosProposicionalesConjuntoClausula s) es el conjunto de los\r\n-- s\u00edmbolos proposicionales de s. Por ejemplo,\r\n--    s\u00edmbolosProposicionalesConjuntoClausula [[p, q],[no q, r]]\r\n--    ==> [p,q,r]\r\n-- ---------------------------------------------------------------------\r\n\r\ns\u00edmbolosProposicionalesConjuntoClausula :: [Clausula] -> [Prop]\r\ns\u00edmbolosProposicionalesConjuntoClausula s =\r\n    unionGeneral [s\u00edmbolosProposicionalesClausula c | c <- s]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Interpretaciones de una clausula                                   --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8: Definir la funci\u00f3n\r\n--    interpretacionesClausula :: Clausula -> [Interpretacion]\r\n-- tal que (interpretacionesClausula c) es el conjunto de\r\n-- interpretaciones de c. Por ejemplo,\r\n--    interpretacionesClausula [p, q, no p]  ==>  [[p,q],[p],[q],[]]\r\n--    interpretacionesClausula []            ==>  [[]]\r\n-- ---------------------------------------------------------------------\r\n\r\ninterpretacionesClausula :: Clausula -> [Interpretacion]\r\ninterpretacionesClausula c =\r\n    subconjuntos (s\u00edmbolosProposicionalesClausula c)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Interpretaciones de un conjunto de clausulas                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9: Definir la funci\u00f3n\r\n--    interpretacionesConjuntoClausula :: [Clausula] -> [Interpretacion]\r\n-- tal que (interpretacionesConjuntoClausula s) es el conjunto de\r\n-- interpretaciones de s. Por ejemplo,\r\n--    interpretacionesConjuntoClausula [[p, no q],[no p, q]]\r\n--    ==> [[p,q],[p],[q],[]]\r\n--    interpretacionesConjuntoClausula []\r\n--    ==> [[]]\r\n-- ---------------------------------------------------------------------\r\n\r\ninterpretacionesConjuntoClausula :: [Clausula] -> [Interpretacion]\r\ninterpretacionesConjuntoClausula c =\r\n    subconjuntos (s\u00edmbolosProposicionalesConjuntoClausula c)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Modelos de clausulas                                               --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10: Definir la funci\u00f3n\r\n--    esModeloLiteral :: Interpretacion -> Literal -> Bool\r\n-- tal que (esModeloLiteral i l) se verifica si i es modelo de l. Por\r\n-- ejemplo, \r\n--    esModeloLiteral [p,r] p       ==>  True\r\n--    esModeloLiteral [p,r] q       ==>  False\r\n--    esModeloLiteral [p,r] (no p)  ==>  False\r\n--    esModeloLiteral [p,r] (no q)  ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesModeloLiteral :: Interpretacion -> Literal -> Bool\r\nesModeloLiteral i (Atom s)       = elem (Atom s) i\r\nesModeloLiteral i (Neg (Atom s)) = notElem (Atom s) i\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11: Definir la funci\u00f3n\r\n--    esModeloClausula :: Interpretacion -> Clausula -> Bool\r\n-- tal que (esModeloClausula i c) se verifica si i es modelo de c . Por\r\n-- ejemplo, \r\n--    esModeloClausula [p,r] [p, q]     ==>  True\r\n--    esModeloClausula [r] [p, no q]    ==>  True\r\n--    esModeloClausula [q,r] [p, no q]  ==>  False\r\n--    esModeloClausula [q,r] []         ==>  False\r\n-- ---------------------------------------------------------------------\r\n\r\nesModeloClausula :: Interpretacion -> Clausula -> Bool\r\nesModeloClausula i c =\r\n    or [esModeloLiteral i l | l <- c]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12: Definir la funci\u00f3n\r\n--    modelosClausula :: Clausula -> [Interpretacion]\r\n-- tal que (modelosClausula c) es la lista de los modelos de c. Por\r\n-- ejemplo, \r\n--    modelosClausula [no p, q]  ==>  [[p,q],[q],[]]\r\n--    modelosClausula [no p, p]  ==>  [[p],[]]\r\n--    modelosClausula []         ==>  []\r\n-- ---------------------------------------------------------------------\r\n\r\nmodelosClausula :: Clausula -> [Interpretacion]\r\nmodelosClausula c =\r\n    [i | i <- interpretacionesClausula c,\r\n         esModeloClausula i c]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Modelos de conjuntos de clausulas                                  --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 13: Definir la funci\u00f3n\r\n--    esModeloConjuntoClausulas :: Interpretacion -> [Clausula] -> Bool\r\n-- tal que (esModeloConjuntoClausulas i c) se verifica si i es modelo de\r\n-- c. Por ejemplo,\r\n--    esModeloConjuntoClausulas [p,r] [[p, no q], [r]]  ==>  True\r\n--    esModeloConjuntoClausulas [p] [[p, no q], [r]]    ==>  False\r\n--    esModeloConjuntoClausulas [p] []                  ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesModeloConjuntoClausulas :: Interpretacion -> [Clausula] -> Bool\r\nesModeloConjuntoClausulas i s =\r\n    and [esModeloClausula i c | c <- s]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14: Definir la funci\u00f3n\r\n--    modelosConjuntoClausulas :: [Clausula] -> [Interpretacion]\r\n-- tal que (modelosConjuntoClausulas s) es la lista de los modelos de\r\n-- s. Por ejemplo, \r\n--    modelosConjuntoClausulas [[no p, q], [no q, p]]    \r\n--    ==> [[p,q],[]]\r\n--    modelosConjuntoClausulas [[no p, q], [p], [no q]]  \r\n--    ==> []\r\n--    modelosConjuntoClausulas [[p, no p, q]]            \r\n--    ==> [[p,q],[p],[q],[]]\r\n-- ---------------------------------------------------------------------\r\n\r\nmodelosConjuntoClausulas :: [Clausula] -> [Interpretacion]\r\nmodelosConjuntoClausulas s =\r\n    [i | i <- interpretacionesConjuntoClausula s,\r\n         esModeloConjuntoClausulas i s] \r\n\r\n-- ---------------------------------------------------------------------\r\n-- Clausulas v\u00e1lidas, satisfacibles e insatisfacibles                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15: Definir la funci\u00f3n\r\n--    esClausulaV\u00e1lida :: Clausula -> Bool\r\n-- tal que (esClausulaV\u00e1lida c) se verifica si la clausula c es\r\n-- v\u00e1lida. Por ejemplo, \r\n--    esClausulaV\u00e1lida [p, q, no p]  ==>  True\r\n--    esClausulaV\u00e1lida [p, q, no r]  ==>  False\r\n--    esClausulaV\u00e1lida []            ==>  False\r\n-- ---------------------------------------------------------------------\r\n\r\nesClausulaV\u00e1lida :: Clausula -> Bool\r\nesClausulaV\u00e1lida c =\r\n    [l | l <- c, elem (complementario l) c] \/= [] \r\n\r\n-- Definici\u00f3n alternativa:\r\nesClausulaV\u00e1lida1 :: Clausula -> Bool\r\nesClausulaV\u00e1lida1 c =\r\n    and [esModeloClausula i c | i <- interpretacionesClausula c]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16: Definir la funci\u00f3n\r\n--    esClausulaInsatisfacible :: Clausula -> Bool\r\n-- tal que (esClausulaInsatisfacible c) se verifica si la clausula c es\r\n-- insatisfacible. Por ejemplo, \r\n--    esClausulaInsatisfacible [p, q, no p]  ==>  False\r\n--    esClausulaInsatisfacible [p, q, no r]  ==>  False\r\n--    esClausulaInsatisfacible []            ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesClausulaInsatisfacible :: Clausula -> Bool\r\nesClausulaInsatisfacible c =\r\n    null c\r\n\r\n-- Definici\u00f3n alternativa:\r\nesClausulaInsatisfacible1 :: Clausula -> Bool\r\nesClausulaInsatisfacible1 c =\r\n    and [not (esModeloClausula i c) | i <- interpretacionesClausula c]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 17: Definir la funci\u00f3n\r\n--    esClausulaSatisfacible :: Clausula -> Bool\r\n-- tal que (esClausulaSatisfacible c) se verifica si la clausula c es\r\n-- satisfacible. Por ejemplo, \r\n--    esClausulaSatisfacible [p, q, no p]  ==>  True\r\n--    esClausulaSatisfacible [p, q, no r]  ==>  True\r\n--    esClausulaSatisfacible []  ==>  False\r\n-- ---------------------------------------------------------------------\r\n\r\nesClausulaSatisfacible :: Clausula -> Bool\r\nesClausulaSatisfacible c =\r\n    not (null c)\r\n\r\n-- Definici\u00f3n alternativa:\r\nesClausulaSatisfacible1 :: Clausula -> Bool\r\nesClausulaSatisfacible1 c =\r\n    or [esModeloClausula i c | i <- interpretacionesClausula c]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Conjuntos v\u00e1lidos, consistentes e inconsistentes de clausulas      --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 18: Definir la funci\u00f3n\r\n--    esConjuntoV\u00e1lidoDeClausulas :: [Clausula] -> Bool\r\n-- tal que (esConjuntoV\u00e1lidoDeClausulas s) se verifica si el conjunto de\r\n-- clausulas s es v\u00e1lido. Por ejemplo,\r\n--    esConjuntoV\u00e1lidoDeClausulas [[no p, q], [no q, p]]  ==>  False\r\n--    esConjuntoV\u00e1lidoDeClausulas [[no p, p], [no q, q]]  ==>  True\r\n--    esConjuntoV\u00e1lidoDeClausulas []                      ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesConjuntoV\u00e1lidoDeClausulas :: [Clausula] -> Bool\r\nesConjuntoV\u00e1lidoDeClausulas s =\r\n    and [esClausulaV\u00e1lida c | c <- s]\r\n\r\n-- Definici\u00f3n alternativa:\r\nesConjuntoV\u00e1lidoDeClausulas1 :: [Clausula] -> Bool\r\nesConjuntoV\u00e1lidoDeClausulas1 s =\r\n    modelosConjuntoClausulas s == interpretacionesConjuntoClausula s\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 19: Definir la funci\u00f3n\r\n--    esConjuntoConsistenteDeClausulas :: [Clausula] -> Bool\r\n-- tal que (esConjuntoConsistenteDeClausulas s) se verifica si el\r\n-- conjunto de clausulas s es consistente. Por ejemplo,\r\n--    esConjuntoConsistenteDeClausulas [[no p, q], [no q, p]]  ==>  True\r\n--    esConjuntoConsistenteDeClausulas [[no p, p], [no q, q]]  ==>  True\r\n--    esConjuntoConsistenteDeClausulas []                      ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesConjuntoConsistenteDeClausulas :: [Clausula] -> Bool\r\nesConjuntoConsistenteDeClausulas s =\r\n    not (null (modelosConjuntoClausulas s))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 20: Definir la funci\u00f3n\r\n--    esConjuntoInconsistenteDeClausulas :: [Clausula] -> Bool\r\n-- tal que (esConjuntoInconsistenteDeClausulas s) se verifica si el\r\n-- conjunto de clausulas s es consistente. Por ejemplo,\r\n--    esConjuntoInconsistenteDeClausulas [[no p,q],[no q,p]]  ==>  False\r\n--    esConjuntoInconsistenteDeClausulas [[no p],[p]]         ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesConjuntoInconsistenteDeClausulas :: [Clausula] -> Bool\r\nesConjuntoInconsistenteDeClausulas s =\r\n    null (modelosConjuntoClausulas s)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Validez de f\u00f3rmulas mediante clausulas                             --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 21: Definir la funci\u00f3n\r\n--    esValidaPorClausulas :: Prop -> Bool\r\n-- tal que (esValidaPorClausulas f) se verifica si el conjunto de\r\n-- clausulas de f es v\u00e1lido. Por ejemplo,\r\n--    esValidaPorClausulas (p --> q)                 ==>  False\r\n--    esValidaPorClausulas (p --> p)                 ==>  True\r\n--    esValidaPorClausulas ((p --> q) \\\/ (q --> p))  ==>  True\r\n-- ---------------------------------------------------------------------\r\n\r\nesValidaPorClausulas :: Prop -> Bool\r\nesValidaPorClausulas f =\r\n    esConjuntoV\u00e1lidoDeClausulas (clausulas f)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Consecuencia mediante clausulas                                    --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 22: Definir la funci\u00f3n\r\n--    esConsecuenciaEntreClausulas :: [Clausula] -> [Clausula] -> Bool\r\n-- tal que (esConsecuenciaEntreClausulas s1 s2) se verifica si todos los\r\n-- modelos de s1 son modelos de s2. Por ejemplo,\r\n--    esConsecuenciaEntreClausulas [[no p,q],[no q,r]] [[no p,r]]  \r\n--    ==> True\r\n--    esConsecuenciaEntreClausulas [[p]] [[p],[q]]                 \r\n--    ==> False\r\n-- ---------------------------------------------------------------------\r\n\r\nesConsecuenciaEntreClausulas :: [Clausula] -> [Clausula] -> Bool\r\nesConsecuenciaEntreClausulas s1 s2 =\r\n    null [i | i <- interpretacionesConjuntoClausula (s1++s2)\r\n            , esModeloConjuntoClausulas i s1\r\n            , not ((esModeloConjuntoClausulas i s2))]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 23: Definir la funci\u00f3n\r\n--    esConsecuenciaPorClausulas1 :: [Prop] -> Prop -> Bool\r\n-- tal que (esConsecuenciaPorClausulas s f) se verifica si las clausulas\r\n-- de f son consecuencias de las de s. Por ejemplo,\r\n--    esConsecuenciaPorClausulas [(p --> q), (q --> r)] (p --> r)\r\n--    ==> True\r\n--    esConsecuenciaPorClausulas [p] (p \/\\ q)\r\n--    ==> False\r\n-- ---------------------------------------------------------------------\r\n\r\nesConsecuenciaPorClausulas :: [Prop] -> Prop -> Bool\r\nesConsecuenciaPorClausulas s f =\r\n    esConsecuenciaEntreClausulas (clausulasConjunto s) (clausulas f)\r\n\r\n-- Definici\u00f3n alternativa:\r\nesConsecuenciaPorClausulas1 :: [Prop] -> Prop -> Bool\r\nesConsecuenciaPorClausulas1 s f =\r\n    esConjuntoInconsistenteDeClausulas (clausulasConjunto ((Neg f):s))\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
En la clase de hoy del curso de L\u00f3gica matem\u00e1tica y fundamentos (de 3\u00ba de Grado en Matem\u00e1ticas) se ha comentado las soluciones de los ejercicios sobre la implementaci\u00f3n en Haskell de las cl\u00e1usulas. Las soluciones de los ejercicios se muestran a continuaci\u00f3n. En los ejercicios se usa el m\u00f3dulo SintaxisSemantica desarrollado en la clase…<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[1],"tags":[270,202],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3321"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=3321"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3321\/revisions"}],"predecessor-version":[{"id":3322,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3321\/revisions\/3322"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3321"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3321"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3321"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}