El sesgo de Chebyshev

PorJosé A. Alonso 23-marzo-202026-marzo-2022

Un número primo distinto de 2 tiene la forma 4k + 1 o 4k + 3. Chebyshev notó en 1853 que la mayoría de las veces hay más números primos de la forma 4k + 3 que números primos de la forma 4k + 1 menores que un número dado. Esto se llama el sesgo de Chebyshev.

Definir las funciones

   distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]
   empatesRestosModulo4 :: [Integer]
   mayoria1RestosModulo4 :: [Integer]
   grafica_Chebyshev :: Int -> IO ()

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]

empatesRestosModulo4 :: [Integer]

mayoria1RestosModulo4 :: [Integer]

grafica_Chebyshev :: Int -> IO ()

tales que

distribucionPrimosModulo4 es la lista de las ternas (p,a,b) tales que p es un números primo, a es la cantidad de primos menores o iguales que p congruentes con 1 módulo 4 y b es la cantidad de primos menores o iguales que p congruentes con 3 módulo 4. Por ejemplo,

     λ> take 7 distribucionPrimosModulo4
     [(2,0,0),(3,0,1),(5,1,1),(7,1,2),(11,1,3),(13,2,3),(17,3,3)]
     λ> distribucionPrimosModulo4 !! (5*10^5)
     (7368791,249888,250112)

λ> take 7 distribucionPrimosModulo4

[(2,0,0),(3,0,1),(5,1,1),(7,1,2),(11,1,3),(13,2,3),(17,3,3)]

λ> distribucionPrimosModulo4 !! (5*10^5)

(7368791,249888,250112)

empatesRestosModulo4 es la lista de los primos p tales que la cantidad de primos menores o iguales que p congruentes con 1 módulo 4 es igual a la cantidad de primos menores o iguales que p congruentes con 3 módulo 4. Por ejemplo,

     λ> take 10 empatesRestosModulo4
     [2,5,17,41,461,26833,26849,26863,26881,26893]
     λ> length (takeWhile (<= 10^6) empatesRestosModulo4)
     112

λ> take 10 empatesRestosModulo4

[2,5,17,41,461,26833,26849,26863,26881,26893]

λ> length (takeWhile (<= 10^6) empatesRestosModulo4)

112

mayoria1RestosModulo4 es la lista de los primos p tales que la cantidad de primos menores o iguales que p congruentes con 1 módulo 4 es mayor que la cantidad de primos menores o iguales que p congruentes con 3 módulo 4. Por ejemplo,

     λ> take 10 mayoria1RestosModulo4
     [26861,616841,616849,616877,616897,616909,616933,616943,616951,616961]
     λ> length (takeWhile (<= 10^6) mayoria1RestosModulo4)
     239

λ> take 10 mayoria1RestosModulo4

[26861,616841,616849,616877,616897,616909,616933,616943,616951,616961]

λ> length (takeWhile (<= 10^6) mayoria1RestosModulo4)

239

(graficaChebyshev n) dibuja la gráfica de los puntos (p,b-a) donde p es uno de los n primeros primos impares, a es la cantidad de primos menores o iguales que p congruentes con 1 módulo 4 y b es la cantidad de primos menores o iguales que p congruentes con 3 módulo 4. Por ejemplo, (graficaChebyshev 5000) dibuja la figura

Soluciones

[schedule expon=’2020-03-30′ expat=»06:00″]

Las soluciones se pueden escribir en los comentarios.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Pensamiento

«El valor de un problema no es tanto el de encontrar la respuesta como el de las ideas e intentos que obliga su resolución.»

Israel Nathan Herstein.

[/schedule]

[schedule on=’2020-03-30′ at=»06:00″]

import Data.Numbers.Primes
import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]
distribucionPrimosModulo4 = (2,0,0) : aux (tail primes) (0, 0)
  where aux (p:ps) (a,b)
          | p `mod` 4 == 1 = (p,a+1,b) : aux ps (a+1,b)
          | otherwise      = (p,a,b+1) : aux ps (a,b+1)

empatesRestosModulo4 :: [Integer]
empatesRestosModulo4 =
  [p | (p,a,b) <- distribucionPrimosModulo4
     , a == b]
  
mayoria1RestosModulo4 :: [Integer]
mayoria1RestosModulo4 =
  [p | (p,a,b) <- distribucionPrimosModulo4
     , a > b]
  
grafica :: Int -> IO ()
grafica n = 
  plotLists [Key Nothing]
            [ [(p, a) | (p,a,b) <- xs]
            , [(p, b) | (p,a,b) <- xs]
            , [(p, b-a) | (p,a,b) <- xs]]
  where xs = take n (tail (distribucionPrimosModulo4))

graficaChebyshev :: Int -> IO ()
graficaChebyshev n = 
  plotList [ Key Nothing
           , PNG "El_sesgo_de_Chebyshev.png"
           ]
           [(p, b-a) | (p,a,b) <- xs]
  where xs = take n (tail (distribucionPrimosModulo4))

import Data.Numbers.Primes

import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]

distribucionPrimosModulo4 = (2,0,0) : aux (tail primes) (0, 0)

where aux (p:ps) (a,b)

| p `mod` 4 == 1 = (p,a+1,b) : aux ps (a+1,b)

| otherwise = (p,a,b+1) : aux ps (a,b+1)

empatesRestosModulo4 :: [Integer]

empatesRestosModulo4 =

[p | (p,a,b) <- distribucionPrimosModulo4

, a == b]

mayoria1RestosModulo4 :: [Integer]

mayoria1RestosModulo4 =

[p | (p,a,b) <- distribucionPrimosModulo4

, a > b]

grafica :: Int -> IO ()

grafica n =

plotLists [Key Nothing]

[ [(p, a) | (p,a,b) <- xs]

, [(p, b) | (p,a,b) <- xs]

, [(p, b-a) | (p,a,b) <- xs]]

where xs = take n (tail (distribucionPrimosModulo4))

graficaChebyshev :: Int -> IO ()

graficaChebyshev n =

plotList [ Key Nothing

, PNG "El_sesgo_de_Chebyshev.png"

]

[(p, b-a) | (p,a,b) <- xs]

where xs = take n (tail (distribucionPrimosModulo4))

Otras soluciones

Se pueden escribir otras soluciones en los comentarios.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

[/schedule]

3 Comentarios

import Data.Numbers.Primes
import Data.List

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]
distribucionPrimosModulo4 =
  [(p,a,b) | p <- primes,
             let a = genericLength $ takeWhile (<=p) p4nM1,
             let b = genericLength $ takeWhile (<=p) p4nM3]
                             
p4nM1 :: [Integer]
p4nM1 = [x | x <- primes, mod x 4 == 1]                                   

p4nM3 :: [Integer]
p4nM3 = [x | x <- primes, mod x 4 == 3]

empatesRestosModulo4 :: [Integer]
empatesRestosModulo4 =
  [fst3 t | t <- distribucionPrimosModulo4,
            snd3 t == thd3 t]

fst3 :: (a,b,c) -> a
fst3 (x,_,_) = x

snd3 :: (a,b,c) -> b
snd3 (_,y,_) = y

thd3 :: (a,b,c) -> c
thd3 (_,_,z) = z

mayoria1RestosModulo4 :: [Integer]
mayoria1RestosModulo4 =
  [fst3 t | t <- distribucionPrimosModulo4, snd3 t > thd3 t]

graficaChebyshev :: Int -> IO ()
graficaChebyshev n = do
  plotList [ Key Nothing
           , PNG "grafica_Chebyshev.png"
           ]
           [(fst3 t, thd3 t - snd3 t) | t <- distribucionPrimosModulo4]

import Data.Numbers.Primes

import Data.List

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]

distribucionPrimosModulo4 =

[(p,a,b) | p <- primes,

let a = genericLength $ takeWhile (<=p) p4nM1,

let b = genericLength $ takeWhile (<=p) p4nM3]

p4nM1 :: [Integer]

p4nM1 = [x | x <- primes, mod x 4 == 1]

p4nM3 :: [Integer]

p4nM3 = [x | x <- primes, mod x 4 == 3]

empatesRestosModulo4 :: [Integer]

empatesRestosModulo4 =

[fst3 t | t <- distribucionPrimosModulo4,

snd3 t == thd3 t]

fst3 :: (a,b,c) -> a

fst3 (x,_,_) = x

snd3 :: (a,b,c) -> b

snd3 (_,y,_) = y

thd3 :: (a,b,c) -> c

thd3 (_,_,z) = z

mayoria1RestosModulo4 :: [Integer]

mayoria1RestosModulo4 =

[fst3 t | t <- distribucionPrimosModulo4, snd3 t > thd3 t]

graficaChebyshev :: Int -> IO ()

graficaChebyshev n = do

plotList [ Key Nothing

, PNG "grafica_Chebyshev.png"

]

[(fst3 t, thd3 t - snd3 t) | t <- distribucionPrimosModulo4]

Responder

import Data.Numbers.Primes
import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]
distribucionPrimosModulo4 = formaterna primes 0 0

formaterna :: [Integer] -> Integer -> Integer -> [(Integer,Integer,Integer)]
formaterna (p:ps) a b
  | mod p 4 == 1 = (p,a+1,b)   : formaterna ps (a+1) b
  | mod p 4 == 3 = (p,a,  b+1) : formaterna ps a     (b+1)
  | otherwise    = (p,a,  b)   : formaterna ps a     b

empatesRestosModulo4 :: [Integer]
empatesRestosModulo4 = [p | (p,a,b) <- distribucionPrimosModulo4, a == b]

mayoria1RestosModulo4 :: [Integer]
mayoria1RestosModulo4  = [p | (p,a,b) <- distribucionPrimosModulo4, a > b]

diferenciaTerna ::[Int] -> Int -> Int ->  [(Int,Int)]
diferenciaTerna (p:ps) a b
  | mod p 4 == 1 = (p,b-a-1) : diferenciaTerna ps (a+1) b
  | mod p 4 == 3 = (p,b+1-a) : diferenciaTerna ps a     (b+1)
  | otherwise    = (p,b-a)   : diferenciaTerna ps a      b


grafica_Chebyshev :: Int -> IO ()
grafica_Chebyshev n = do
  plotLists [ Key Nothing
            , Title ("grafica Chebyshev") ]
            [take n (tail (diferenciaTerna primes 0 0))]

import Data.Numbers.Primes

import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer, Integer, Integer)]

distribucionPrimosModulo4 = formaterna primes 0 0

formaterna :: [Integer] -> Integer -> Integer -> [(Integer,Integer,Integer)]

formaterna (p:ps) a b

| mod p 4 == 1 = (p,a+1,b) : formaterna ps (a+1) b

| mod p 4 == 3 = (p,a, b+1) : formaterna ps a (b+1)

| otherwise = (p,a, b) : formaterna ps a b

empatesRestosModulo4 :: [Integer]

empatesRestosModulo4 = [p | (p,a,b) <- distribucionPrimosModulo4, a == b]

mayoria1RestosModulo4 :: [Integer]

mayoria1RestosModulo4 = [p | (p,a,b) <- distribucionPrimosModulo4, a > b]

diferenciaTerna ::[Int] -> Int -> Int -> [(Int,Int)]

diferenciaTerna (p:ps) a b

| mod p 4 == 1 = (p,b-a-1) : diferenciaTerna ps (a+1) b

| mod p 4 == 3 = (p,b+1-a) : diferenciaTerna ps a (b+1)

| otherwise = (p,b-a) : diferenciaTerna ps a b

grafica_Chebyshev :: Int -> IO ()

grafica_Chebyshev n = do

plotLists [ Key Nothing

, Title ("grafica Chebyshev") ]

[take n (tail (diferenciaTerna primes 0 0))]

Responder

import Data.Numbers.Primes
import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer,Integer,Integer)]
distribucionPrimosModulo4 =
  [(p,a,b) | p <- primes,
             let a = genericLength (takeWhile (<=p) xs),
             let b = genericLength (takeWhile (<=p) ys)]
  where xs = [x | x <- primes, mod x 4 == 1]
        ys = [y | y <- primes, mod y 4 == 3]

empatesRestosModulo4 :: [Integer]
empatesRestosModulo4 =
  [fst' x | x <- distribucionPrimosModulo4, snd' x == thd' x]
  where fst' (a,_,_) = a
        snd' (_,b,_) = b
        thd' (_,_,c) = c

mayoria1RestosModulo4 :: [Integer]
mayoria1RestosModulo4 =
  [fst' x | x <- distribucionPrimosModulo4, snd' x > thd' x]
  where fst' (a,_,_) = a
        snd' (_,b,_) = b
        thd' (_,_,c) = c

grafica_Chebyshev :: Int -> IO ()
grafica_Chebyshev n = do
  plotList [ Key Nothing, PNG "grafica_Chebyshev.png"]
           [(fst' x, thd' x - snd' x)
           | x <- take n distribucionPrimosModulo4]
  where fst' (a,_,_) = a
        snd' (_,b,_) = b
        thd' (_,_,c) = c

import Data.Numbers.Primes

import Graphics.Gnuplot.Simple

distribucionPrimosModulo4 :: [(Integer,Integer,Integer)]

distribucionPrimosModulo4 =

[(p,a,b) | p <- primes,

let a = genericLength (takeWhile (<=p) xs),

let b = genericLength (takeWhile (<=p) ys)]

where xs = [x | x <- primes, mod x 4 == 1]

ys = [y | y <- primes, mod y 4 == 3]

empatesRestosModulo4 :: [Integer]

empatesRestosModulo4 =

[fst' x | x <- distribucionPrimosModulo4, snd' x == thd' x]

where fst' (a,_,_) = a

snd' (_,b,_) = b

thd' (_,_,c) = c

mayoria1RestosModulo4 :: [Integer]

mayoria1RestosModulo4 =

[fst' x | x <- distribucionPrimosModulo4, snd' x > thd' x]

where fst' (a,_,_) = a

snd' (_,b,_) = b

thd' (_,_,c) = c

grafica_Chebyshev :: Int -> IO ()

grafica_Chebyshev n = do

plotList [ Key Nothing, PNG "grafica_Chebyshev.png"]

[(fst' x, thd' x - snd' x)

| x <- take n distribucionPrimosModulo4]

where fst' (a,_,_) = a

snd' (_,b,_) = b

thd' (_,_,c) = c

Responder

El sesgo de Chebyshev

Soluciones

Pensamiento

Otras soluciones

3 Comentarios

Leave a Reply to jospergar20Cancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Pensamiento

Otras soluciones

Se puede imprimir o compartir con

3 Comentarios

Leave a Reply to jospergar20Cancel reply

Entradas recientes

Buscar

Correo electrónico