PeH: La conjetura de Gilbreath en Haskell
Se considera el siguiente proceso: (1) escribir los 5 primeros números primos, (2) restar cada dos números consecutivos, escribiendo los resultados en valor absoluto, hasta quedarse con un único número se obtiene la siguiente tabla:
|
1 2 3 4 5 |
2, 3, 5, 7, 11 1, 2, 2, 4 1, 0, 2 1, 2 1 |
Se observa que todas las filas comienza con el número 1.
Repitiendo el proceso empezando con los 8 primeros números primos se obtiene la siguiente tabla:
|
1 2 3 4 5 6 7 8 |
2, 3, 5, 7, 11, 13, 17, 19 1, 2, 2, 4, 2, 4, 2 1, 0, 2, 2, 2, 2 1, 2, 0, 0, 0 1, 2, 0, 0 1, 2, 0 1, 2 1 |
Se observa que, de nuevo, todas las filas comienza con el número 1.
La conjetura de Gilbreath afirma que si escribimos la sucesión de números primos completa y después construimos las correspondientes sucesiones formadas por el valor absoluto de la resta de cada pareja de números consecutivos, entonces todas esas filas que obtenemos comienzan siempre por 1.
En los siguiente ejercicios comprobaremos experimentalmente con Haskell dicha conjetura. Para la representación, usaremos la simétrica de la que
hemos comentado anteriormente; es decir,
|
1 2 3 4 5 6 7 8 |
2 3, 1 5, 2, 1 7, 2, 0, 1 11, 4, 2, 2, 1 13, 2, 2, 0, 2, 1 17, 4, 2, 0, 0, 2, 1 19, 2, 2, 0, 0, 0, 2, 1 |
en la que la primera columna son los números primos y el elemento de la fila i y columna j (con i, j > 1) es el valor absoluto de la diferencia de los elementos (i,j-1) e (i-1,j-1).
La relación de ejercicios (elaboradad para la asignatura de Informática de 1º del Grado en Matemáticas y para la siguiente versión del libro Piensa en Haskell) es
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
-- --------------------------------------------------------------------- -- § Librerías auxiliares -- -- --------------------------------------------------------------------- import Data.Numbers.Primes -- --------------------------------------------------------------------- -- Ejercicio 1. Definir a función -- siguiente :: Integer -> [Integer] -> [Integer] -- tal que (siguiente x ys) es la línea siguiente de la ys que empieza -- por x en la tabla de Gilbreath; es decir, si ys es [y1,y2,...,yn], -- entonces (siguiente x ys) es -- [x,|y1-x|,|y2-|y1-x||,...] -- Por ejemplo, -- siguiente 7 [5,2,1] == [7,2,0,1] -- siguiente 29 [23,4,2,0,0,0,0,2,1] == [29,6,2,0,0,0,0,0,2,1] -- --------------------------------------------------------------------- siguiente :: Integer -> [Integer] -> [Integer] siguiente x ys = scanl (\m n -> abs(m-n)) x ys -- --------------------------------------------------------------------- -- Ejercicio 2. Definir la función -- triangulo :: [[Integer]] -- tal que triangulo es el triangulo de Gilbreath. Por ejemplo, -- ghci> take 10 triangulo -- [[ 2], -- [ 3,1], -- [ 5,2,1], -- [ 7,2,0,1], -- [11,4,2,2,1], -- [13,2,2,0,2,1], -- [17,4,2,0,0,2,1], -- [19,2,2,0,0,0,2,1], -- [23,4,2,0,0,0,0,2,1], -- [29,6,2,0,0,0,0,0,2,1]] -- --------------------------------------------------------------------- triangulo :: [[Integer]] triangulo = [2] : [siguiente x ys | (x,ys) <- zip (tail primes) triangulo] -- --------------------------------------------------------------------- -- Ejercicio 3. Definir la función -- conjetura_Gilbreath :: Int -> Bool -- tal que (conjetura_Gilbreath n) se verifica si se cumple la conjetura -- de Gilbreath para los n primeros números primos; es decir, en el -- triángulo de Gilbreath cuya primera columna son los n primeros -- números primos, todas las filas a partir de la segunda terminan en 1. -- --------------------------------------------------------------------- conjetura_Gilbreath :: Int -> Bool conjetura_Gilbreath n = all p (tail (take n triangulo)) where p xs = last xs == 1 -- --------------------------------------------------------------------- -- Ejercicio 4. Comprobar la conjetura de Gilbreath para los 1000 -- primeros números primos. -- --------------------------------------------------------------------- -- La comprobación es -- ghci> conjetura_Gilbreath 1000 -- True |
Referencias