{"id":4067,"date":"2014-01-28T21:48:27","date_gmt":"2014-01-28T20:48:27","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=4067"},"modified":"2014-01-29T08:24:25","modified_gmt":"2014-01-29T07:24:25","slug":"numeros-triangulares-y-sus-propiedades-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/numeros-triangulares-y-sus-propiedades-en-haskell\/","title":{"rendered":"N\u00fameros triangulares y sus propiedades en Haskell"},"content":{"rendered":"<p>Los <a href=\"http:\/\/es.wikipedia.org\/wiki\/N\u00famero_triangular\">n\u00fameros triangulares<\/a> se forman como sigue<br \/>\n<a href=\"https:\/\/i0.wp.com\/www.glc.us.es\/~jalonso\/vestigium\/wp-content\/uploads\/2014\/01\/triangulares.gif?ssl=1\"><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/i0.wp.com\/www.glc.us.es\/~jalonso\/vestigium\/wp-content\/uploads\/2014\/01\/triangulares.gif?resize=500%2C77&#038;ssl=1\" alt=\"triangulares\" width=\"500\" height=\"77\" class=\"aligncenter size-full wp-image-4070\" data-recalc-dims=\"1\" \/><\/a>\n<\/p>\n<p>En la siguiente relaci\u00f3n de ejercicios (elaborada para <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m\">I1M<\/a>) se muestran distintas definiciones de los n\u00fameros triangulares y algunas de sus propiedades en Haskell.<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 Librer\u00edas auxiliares                                             --\r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.List\r\nimport Test.QuickCheck\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 N\u00fameros triangulares                                             --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    triangularR :: Integer -> Integer\r\n-- tal que (triangularR n) es el n-\u00e9simo n\u00famero triangular. Por ejemplo,\r\n--    triangularR 3  ==  6\r\n--    triangularR 4  ==  10\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangularR :: Integer -> Integer\r\ntriangularR 1 = 1\r\ntriangularR n = n + triangularR (n-1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2. Definir, por comprensi\u00f3n, la funci\u00f3n\r\n--    triangularC :: Integer -> Integer\r\n-- tal que (triangularC n) es el n-\u00e9simo n\u00famero triangular. Por ejemplo,\r\n--    triangularC 3  ==  6\r\n--    triangularC 4  ==  10\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangularC :: Integer -> Integer\r\ntriangularC n = sum [1..n]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. Definir, mediante una f\u00f3rmula, la funci\u00f3n\r\n--    triangular :: Integer -> Integer\r\n-- tal que (triangular n) es el n-\u00e9simo n\u00famero triangular. Por ejemplo,\r\n--    triangular 3  ==  6\r\n--    triangular 4  ==  10\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangular :: Integer -> Integer\r\ntriangular n = n*(n+1) `div` 2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4. Comprobar con QuickCheck que las tres definiciones\r\n-- anteriores son equivalentes. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La propiedad es\r\nprop_equivalencia :: Integer -> Property\r\nprop_equivalencia n =\r\n    n > 0 ==> triangular n == triangularR n &&\r\n              triangular n == triangularC n \r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_equivalencia\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5. Comparar el tiempo y espacio utilizado en los\r\n-- siguientes c\u00e1lculos\r\n--    triangularR 1000000\r\n--    triangularC 1000000\r\n--    triangular  1000000\r\n-- ---------------------------------------------------------------------\r\n\r\n--    ghci> triangularR 1000000\r\n--    500000500000\r\n--    (1.80 secs, 173351432 bytes)\r\n--    ghci> triangularC 1000000\r\n--    500000500000\r\n--    (0.79 secs, 140856704 bytes)\r\n--    ghci> triangular 1000000\r\n--    500000500000\r\n--    (0.01 secs, 521392 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 Suma de pares de triangulares consecutivos                       --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Definir, usando triangular, la funci\u00f3n\r\n--    sumaTriangularesConsecutivos :: Integer -> Integer\r\n-- tal que (sumaTriangularesConsecutivos n) es la suma de n\u00famero\r\n-- triangular n-\u00e9simo y su siguiente n\u00famero triangular. Por ejemplo,\r\n--    sumaTriangularesConsecutivos 3  ==  16\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaTriangularesConsecutivos :: Integer -> Integer\r\nsumaTriangularesConsecutivos n = \r\n    triangular n + triangular (n+1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Calcular los valores de (sumaTriangularesConsecutivos n)\r\n-- para n entre 1 y 10. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> [sumaTriangularesConsecutivos n | n <- [1..10]]\r\n--    [4,9,16,25,36,49,64,81,100,121]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8. A partir del c\u00e1lculo del ejercicio anterior conjeturar\r\n-- una f\u00f3rmula para calcular (sumaTriangularesConsecutivos n) y\r\n-- comprobarla con  QuickCheck. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La conjetura es que (sumaTriangularesConsecutivos n) = (n+1)^2\r\nconjetura :: Integer -> Property\r\nconjetura n =\r\n    n > 0 ==> sumaTriangularesConsecutivos n == (n+1)^2\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck conjetura\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 La sucesi\u00f3n de n\u00fameros triangulares                              --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9. Definir, usando triangular, la funci\u00f3n\r\n--    triangulares1 :: [Integer]\r\n-- tal que triangulares1 es la lista de los n\u00fameros triangulares. Por\r\n-- ejemplo, \r\n--    take 10 triangulares1  ==  [1,3,6,10,15,21,28,36,45,55]\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangulares1 :: [Integer]\r\ntriangulares1 = [triangular n | n <- [1..]]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10. Definir, por recursi\u00f3n, la funci\u00f3n\r\n--    triangulares2 :: [Integer]\r\n-- tal que triangulares2 es la lista de los n\u00fameros triangulares. Por\r\n-- ejemplo, \r\n--    take 10 triangulares2  ==  [1,3,6,10,15,21,28,36,45,55]\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangulares2 :: [Integer]\r\ntriangulares2 = 1 : zipWith (+) [2..] triangulares2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 11. Definir, usando scanl, la funci\u00f3n\r\n--    triangulares3 :: [Integer]\r\n-- tal que triangulares3 es la lista de los n\u00fameros triangulares. Por\r\n-- ejemplo, \r\n--    take 10 triangulares3  ==  [1,3,6,10,15,21,28,36,45,55]\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangulares3 :: [Integer]\r\ntriangulares3 = scanl (+) 1 [2..]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 12. Definir la funci\u00f3n\r\n--    prop_equivalentes_triangulares :: Int -> Bool\r\n-- tal que (prop_equivalentes_triangulares n) se verifica si las tres\r\n-- definiciones de triangulares coinciden para todos los n\u00fameros entre 1\r\n-- y n. \r\n--\r\n-- Comprobar si coinciden para los n\u00fameros entre 1 y 1000.\r\n-- ---------------------------------------------------------------------\r\n\r\nprop_equivalentes_triangulares :: Int -> Bool\r\nprop_equivalentes_triangulares n =\r\n    take n triangulares2 == xs && \r\n    take n triangulares3 == xs\r\n    where xs = take n triangulares1\r\n\r\n-- La comprobaci\u00f3n  es\r\n--    ghci> prop_equivalentes_triangulares 1000\r\n--    True\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 Suma de n\u00fameros triangulares                                     --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 13. Definir, usando triangulares1, la funci\u00f3n\r\n--    sumaTriangulares1 :: Integer -> Integer\r\n-- tal que (sumaTriangulares1 n) es la suma de los n primeros n\u00fameros\r\n-- triangulares. Por ejemplo,\r\n--    sumaTriangulares1 5  ==  35\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaTriangulares1 :: Integer -> Integer\r\nsumaTriangulares1 n = sum (genericTake n triangulares1)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 14. Definir, usando triangulares1, la funci\u00f3n\r\n--    sumaTriangulares2 :: Integer -> Integer\r\n-- tal que (sumaTriangulares2 n) es la suma de los n primeros n\u00fameros\r\n-- triangulares. Por ejemplo,\r\n--    sumaTriangulares2 5  ==  35\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaTriangulares2 :: Integer -> Integer\r\nsumaTriangulares2 n = sum (genericTake n triangulares2)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 15. Definir, usando triangulares3, la funci\u00f3n\r\n--    sumaTriangulares3 :: Integer -> Integer\r\n-- tal que (sumaTriangulares3 n) es la suma de los n primeros n\u00fameros\r\n-- triangulares. Por ejemplo,\r\n--    sumaTriangulares3 5  ==  35\r\n-- ---------------------------------------------------------------------\r\n\r\nsumaTriangulares3 :: Integer -> Integer\r\nsumaTriangulares3 n = sum (genericTake n triangulares3)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 16. Comparar el tiempo y espacio utilizado en los\r\n-- siguientes c\u00e1lculos\r\n--    sumaTriangulares1 1000000\r\n--    sumaTriangulares2 1000000\r\n--    sumaTriangulares3 1000000\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> sumaTriangulares1 1000000\r\n--    166667166667000000\r\n--    (3.57 secs, 480278768 bytes)\r\n--    ghci> sumaTriangulares2 1000000\r\n--    166667166667000000\r\n--    (1.84 secs, 322014636 bytes)\r\n--    ghci> sumaTriangulares3 1000000\r\n--    166667166667000000\r\n--    (1.81 secs, 321983444 bytes)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 17. Calcular las sumas de los n primeros n\u00fameros\r\n-- triangulares para n entre 1 y 5.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> [sumaTriangulares3 n | n <- [1..5]]\r\n--    [1,4,10,20,35]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 18. A partir del c\u00e1lculo anterior, conjeturar una f\u00f3rmula\r\n-- para calcular la suma de los primeros n n\u00fameros triangulares.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- Usando Wolfram Alpha (como se muestra en http:\/\/wolfr.am\/MoPMXY ) se\r\n-- obtiene que la suma de los primeros n n\u00fameros triangulares es\r\n--    n*(n+1)*(n+2)\/6\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 19. Comprobar con QuickCheck la conjetura obtenida en el\r\n-- ejercicio anterior.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La conjetura es\r\nprop_sumaTriangulares :: Integer -> Property\r\nprop_sumaTriangulares n =\r\n    n > 0 ==> sumaTriangulares3 n == (n*(n+1)*(n+2)) `div` 6\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_sumaTriangulares\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 Teorema de Gauss                                                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 20. Definir la funci\u00f3n \r\n--    sumas :: [Integer] -> Integer -> Integer -> [[Integer]]\r\n-- tal que (sumas xs m n) es la lista de las de listas crecientes de,\r\n-- como m\u00e1ximo, m elementos de la lista ordenada creciente xs cuya suma\r\n-- es n. Por ejemplo, \r\n--    ghci> sumas [1..9] 2 7\r\n--    [[1,6],[2,5],[3,4],[7]]\r\n--    ghci> sumas [1..9] 3 7\r\n--    [[1,1,5],[1,2,4],[1,3,3],[1,6],[2,2,3],[2,5],[3,4],[7]]\r\n-- ---------------------------------------------------------------------\r\n\r\nsumas :: [Integer] -> Integer -> Integer -> [[Integer]]\r\nsumas _  _ 0 = [[]]\r\nsumas [] _ _ = []\r\nsumas _  0 _ = []\r\nsumas (x:xs) m n\r\n    | x > n     = []\r\n    | otherwise = [x:ys | ys <- sumas (x:xs) (m-1) (n-x)] ++ \r\n                  sumas xs m n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 21. Definir la funci\u00f3n\r\n--    descomposicionesTriangulares :: Integer -> Integer -> [[Integer]]\r\n-- tal que (descomposicionesTriangulares m n) es la lista crecientes de,\r\n-- como m\u00e1ximo m n\u00fameros triangulares, cuya suma es n. Por ejemplo,\r\n--    descomposicionesTriangulares 3 5   ==  [[1,1,3]]\r\n--    descomposicionesTriangulares 3 6   ==  [[3,3],[6]]\r\n--    descomposicionesTriangulares 3 20  ==  [[10,10]]\r\n--    descomposicionesTriangulares 3 12  ==  [[1,1,10],[3,3,6],[6,6]]\r\n-- ---------------------------------------------------------------------\r\n\r\ndescomposicionesTriangulares :: Integer -> Integer -> [[Integer]]\r\ndescomposicionesTriangulares m n = \r\n    sumas (takeWhile (<=n) triangulares3) m n\r\n\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 22. Definir \r\n--    gradoTriangular :: Integer -> Integer\r\n-- tal que (gradoTriangular n) es el menor cantidad de n\u00fameros\r\n-- triangulares cuya suma es n. Por ejemplo,\r\n--    gradoTriangular 5  ==  3\r\n--    gradoTriangular 6  ==  1\r\n--    gradoTriangular 4  ==  2\r\n-- ---------------------------------------------------------------------\r\n\r\ngradoTriangular :: Integer -> Integer\r\ngradoTriangular n = \r\n    minimum [m | m <- [1..n], not (null (descomposicionesTriangulares m n))]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 23. Calcular el n\u00famero m\u00ednimo de sumandos para expresar\r\n-- cualquiera de los 20 primeros n\u00fameros naturales.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> [gradoTriangular n | n <- [1..20]]\r\n--    [1,2,1,2,3,1,2,3,2,1,2,2,2,3,1,2,3,2,3,2]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 24. A la vista del c\u00e1lculo del ejercicio anterior,\r\n-- conjeturar la menor cota superior del n\u00famero m\u00ednimo de sumandos para\r\n-- expresar cualquiera n\u00famero natural y comprobar la conjetura con\r\n-- QuickCheck. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- La conjetura es que todos los n\u00fameros naturales se pueden expresar\r\n-- como suma de tres, o menos, n\u00fameros triangulares (no necesariamente\r\n-- distintos). \r\n\r\n-- La expresi\u00f3n de la conjetura\r\nprop_gradoTriangular :: Integer -> Property\r\nprop_gradoTriangular n =\r\n    n >= 0 ==> not (null (descomposicionesTriangulares 3 n))\r\n\r\n-- La comprobaci\u00f3n es\r\n--    ghci> quickCheck prop_gradoTriangular\r\n--    +++ OK, passed 100 tests.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Nota 1. En 1796, el matem\u00e1tico y cient\u00edfico alem\u00e1n Carl Friedrich\r\n-- Gauss descubri\u00f3 que todo entero positivo puede representarse como la\r\n-- suma de un m\u00e1ximo de tres n\u00fameros triangulares, hecho que describi\u00f3\r\n-- en su diario con la misma palabra que usara Arqu\u00edmedes en su famoso\r\n-- descubrimiento: \"\u00a1Eureka! num= \u0394 + \u0394 + \u0394\". \r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- \u00a7 N\u00fameros triangulares de Mersenne                                 --\r\n-- ---------------------------------------------------------------------\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 25. Definir la funci\u00f3n\r\n--    esTriangular :: Integer -> Bool\r\n-- tal que (esTriangular n) se verifica si n es un n\u00famero\r\n-- triangular. Por ejemplo,\r\n--    esTriangular 10  ==  True\r\n--    esTriangular 12  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nesTriangular :: Integer -> Bool\r\nesTriangular n = \r\n    n == head (dropWhile (<n) triangulares3)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 26. Los n\u00fameros n\u00fameros triangulares de Mersenne son los\r\n-- n\u00fameros triangulares de la forma 2^b-1.\r\n--\r\n-- Definir la funci\u00f3n\r\n--    triangularesMersenne :: [Integer]\r\n-- tal que triangularesMersenne es la lista de los n\u00fameros triangulares\r\n-- de Mersenne. Por ejemplo,\r\n--    take 3 triangularesMersenne  ==  [1,3,15]\r\n-- ---------------------------------------------------------------------\r\n\r\ntriangularesMersenne :: [Integer]\r\ntriangularesMersenne =\r\n    [2^b-1 | b <- [0..], esTriangular (2^b-1)]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 27. Calcular la lista de los n\u00fameros triangulares de\r\n-- Mersenne. \r\n-- ---------------------------------------------------------------------\r\n\r\n-- El c\u00e1lculo es\r\n--    ghci> triangularesMersenne\r\n--    [1,3,15,4095  C-c C-c Interrupted.\r\n-- He abortado el c\u00e1lculo, porque pasaba tiempo sin encontrar ning\u00fan\r\n-- nuevo n\u00famero.\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 28. A la vista del c\u00e1lculo anterior, conjeturar cu\u00e1l es el\r\n-- mayor n\u00famero triangular de Mersenne y comprobarla con QuickCheck.\r\n-- ---------------------------------------------------------------------\r\n\r\n-- La conjetura es que el mayor n\u00famero triangular de Mersenne es\r\n-- 4095. Puesto que 4095 = 2^12-1, la expresi\u00f3n de la conjetura es para\r\n-- los exponentes entre 13 y n es\r\nprop_triangularMersenne :: Integer -> Bool\r\nprop_triangularMersenne n =\r\n    and [not (esTriangular (2^b-1)) | b <- [13..n]]\r\n\r\n-- La comprobaci\u00f3n para n = 40 es\r\n--    ghci> prop_triangularMersenne 40\r\n--    True\r\n<\/pre>\n<p><b>Fuente<\/b><\/p>\n<ul>\n<li>Wikipedia. <a href=\"http:\/\/bit.ly\/1mRaMRC\">N\u00famero triangular<\/a>.\n<li>Wikipedia. <a href=\"http:\/\/bit.ly\/1d65FYn\">N\u00fameros triangulares de Mersenne<\/a>.\n<\/ul>\n<p><b>Destino<\/b><br \/>\nLa anterior relaci\u00f3n de ejercicios la ha elaborado para <\/p>\n<ul>\n<li>la asignatura de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> y\n<li>la ampliaci\u00f3n del libro <a href=\"http:\/\/www.cs.us.es\/~jalonso\/publicaciones\/Piensa_en_Haskell.pdf\">Piensa en Haskell<\/a>.\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Los n\u00fameros triangulares se forman como sigue En la siguiente relaci\u00f3n de ejercicios (elaborada para I1M) se muestran distintas definiciones de los n\u00fameros triangulares y algunas de sus propiedades en Haskell.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","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":[221],"tags":[270,279,299],"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\/4067"}],"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=4067"}],"version-history":[{"count":9,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4067\/revisions"}],"predecessor-version":[{"id":4077,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4067\/revisions\/4077"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=4067"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=4067"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=4067"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}