Constante aproximada de Brun

25

La constante de Brun es el valor al que converge la suma de los recíprocos de los pares primos gemelos ( 1/py 1/(p+2)dónde py p+2ambos son primos). Es aproximadamente 1.902160583104.

Dado un entero positivo N, aproxima la constante de Brun sumando los recíprocos de los pares primos gemelos donde ambos primos en el par son menores que N, y genera la aproximación.

Reglas

  • N será un número entero positivo dentro del rango representable para su idioma.
  • La salida debe ser lo más precisa posible al valor verdadero, dentro de los límites de la implementación de punto flotante de su idioma, ignorando cualquier problema potencial debido a imprecisiones aritméticas de punto flotante. Si su lenguaje es capaz de aritmética de precisión arbitraria, debe ser al menos tan precisa como la aritmética de precisión doble IEEE 754.
  • Alternativamente, se puede generar una fracción exacta en cualquier formato consistente y sin ambigüedades.
  • Si un primo aparece en múltiples pares primos gemelos (por ejemplo 5, parte de ambos (3, 5)y (5, 7)), su recíproco contribuye a la suma cada vez.

Casos de prueba

2 -> 0
6 -> 0.5333333333333333
10 -> 0.8761904761904762
13 -> 0.8761904761904762
100 -> 1.3309903657190867
620 -> 1.4999706034568274
100000 -> 1.67279958482774
Mego
fuente
¿Se puede generar una fracción exacta?
LegionMammal978
@ LegionMammal978 Sí, lo aclararé.
Mego
Nota al margen: el valor 1.902160583104 ... para la constante de Brun solo se conjetura; ni siquiera la primera cifra significativa ha sido rigurosamente calculada (es decir, ni siquiera se sabe si es mayor o menor que 2).
Greg Martin el
@GregMartin Si bien eso es cierto, también es la mejor aproximación que tenemos actualmente.
Mego
5 es el único número primo que aparece en dos pares primos
Christian Sievers

Respuestas:

25

Python 3 , 78 77 75 70 68 62 bytes

f=lambda n,k=3,m=1,j=0:k<n and-m%k*j*2/k+f(n,k+2,m*k**4,m%k/k)

¡Gracias a @xnor por jugar 2 4 bytes y allanar el camino para 4 más!

Pruébalo en línea!

Fondo

Recordemos que el teorema de Wilson establece que para todos los enteros k> 1 ,

donde a ≡ b (mod d) significa que a - b es divisible por d , es decir, a y b tienen el mismo residuo cuando se divide por d .

En Wilson Theorems for Double-, Hyper-, Sub- and Super-factorials , los autores prueban generalizaciones para factoriales dobles, sobre los que se basa esta respuesta. El factorial doble de un entero k ≥ 0 se define por

El teorema 4 del trabajo antes mencionado establece lo siguiente.

Elevando ambos lados de las congruencias al cuarto poder, deducimos que

para todos los números primos impares p . Desde 1 !! = 1 , la equivalencia se cumple también para p = 2 .

Ahora, hacer lo mismo con el teorema de Wilson revela que

Ya que

resulta que

siempre que p es primo.

Ahora, que k sea ​​un número entero extraño, positivo y compuesto. Por definición, existen enteros a, b> 1 tales que k = ab .

Como k es impar, también lo son a y b . Por lo tanto, ambos ocurren en la secuencia 1, 3, ..., k - 2 y

donde | Indica divisibilidad.

Resumiendo, para todos los enteros impares k> 1

donde p (k) = 1 si k es primo y p (k) = 0 si k es compuesto.

Cómo funciona

Cuando se llama a la función f con un único argumento, k , m y j se inicializan como 3 , 1 y 0 .

Tenga en cuenta que ((k - 2) !!) 4 = 1 !! 4 = 1 = m . De hecho, la igualdad m = ((k - 2) !!) 4 se mantendrá en todo momento. j es flotante y siempre será igual a ((k - 4) !!) 4 % (k - 2) / (k - 2) .

Mientras k <n , andse evaluará el argumento correcto de . Como j = ((k - 4) !!) 4 % (k - 2) / (k - 2) , como se demuestra en el primer párrafo, j = 1 / (k - 2) si k - 2 es primo y j = 0 si no. Del mismo modo, dado que m% k = ((k - 2) !!) 4 es igual a 1 si k es primo y 0 si no, -m% k = k - 1 si k es primo y -m% k = 0 si no. Por lo tanto, se -m%k*j*2/kevalúa como 2 (k - 1) / (k (k - 2)) = ((k - 2) + k) / (k (k - 2)) = 1 / k + 1 / (k - 2) si el par (k - 2, k)consiste en primos gemelos y en 0 si no.

Después de calcular lo anterior, agregamos el resultado al valor de retorno de la llamada recursiva f(n,k+2,m*k**4,m%k/k). k se incrementa en 2, por lo que solo toma valores impares ‡ † , multiplicamos m por k 4 ya que mk 4 = ((k - 2) !!) 4 k 4 = (k !!) 4 y pasamos el valor actual de m% k / k , que es igual a 1 / k si el "viejo" k es primo y 0 si no, como parámetro j para la llamada a la función.

Finalmente, una vez que k es igual o mayor que n , f devolverá False y la recursión se detendrá. El valor de retorno de f (n) será la suma de todos 1 / k + 1 / (k - 2) tal que (k - 2, k) es un par primo gemelo yk <n , según se desee.


Los resultados del párrafo Fondo solo se mantienen para enteros impares. Dado que incluso los enteros no pueden ser primos gemelos, podemos omitirlos de manera segura.

Dennis
fuente
Creo que tu expresión es la misma que m%k*(j/k+j/(k-2)).
xnor
Si, eso funciona. ¡Gracias!
Dennis
Buena observación de ese ((k-2)!!)^4 = p(k)módulo ppara impar p. No he trabajado con su argumento, pero aquí hay uno que se me ocurrió (que podría ser lo mismo en esencia). Módulo de trabajo pen el set {1,2,..,p-1}, las igualaciones son exactamente las negativas de las probabilidades. Por lo tanto, prod(odds) = ± prod(evens). El teorema de Wilson nos dice eso prod(all) = - p(k). Desde entonces prod(all) = prod(odds) * prod(evens) = prod(odds) * ± prod(evens), tenemos prod(odds)^2 = ±p(k)y así prod(odds)^4 = p(k)^2 = p(k).
xnor
¡Agradable! Intenté expresar la suma como una sola fracción, pero no se me ocurrió calcular parte de ella en j . ¡Gracias de nuevo! Su prueba es mucho más simple que la del documento.
Dennis
7

Jalea , 15 14 bytes

’ÆRµ_2fµ+2;µİS

Pruébalo en línea!

Cómo funciona

’ÆRµ_2fµ+2;µİS  Main link. Argument: n

’               Decrement; yield n-1.
 ÆR             Prime range; yield all primes in [1, ..., n-1].
   µ            New chain. Argument: r (prime range)
    _2          Subtract 2 from all primes.
      f         Filter; keep all p-2 that appear in r.
       µ        New chain. Argument: t (filtered range)
        +2      Add 2 to all primes in s.
          ;     Concatenate with s.
           µ    New chain. Argument: t (twin primes)
            İ   Take the inverses.
             S  Sum.
Dennis
fuente
5

Gelatina , 16 14 bytes (con un poco de ayuda de @Dennis)

’ÆRṡ2_/2+$$ÐḟFİS

Pruébalo en línea!

Mientras intentaba mejorar mi respuesta anterior, pensé en un algoritmo totalmente diferente, y es algo más corto. Estoy usando una publicación diferente, como es el estándar aquí para una respuesta que usa una técnica diferente.

Dennis sugiriendo reemplazar _/2+$$ÐḟconIċ¥Ðf2 ; Me había olvidado por completo de la posibilidad de un filtro diádico. Como tal, este algoritmo ahora se vincula con el que utilizó la respuesta de Dennis.

Explicación

’ÆRṡ2Iċ¥Ðf2FİS
’                  Decrement.
 ÆR                Primes from 2 to the argument inclusive
                   (i.e. 2 to the original input exclusive).
   ṡ2              Take overlapping slices of size 2.
        Ðf         Keep only elements where the following is true:
       ¥           {the second parse of, which parses like this}
     Iċ   2          the differences (I) contain (ċ) 2
           F       Flatten.
            İ      Take 1/x {for every list element}.
             S     Sum.

fuente
2_/2+$$Ðḟpuede llegar a ser Iċ¥Ðf2.
Dennis
4

Brachylog , 17 bytes

{>I-₂:I{ṗ/₁}ᵐ}ᶠc+

Pruébalo en línea!

¡Esta es la nueva versión de Brachylog, con una página de códigos brillante!

Explicación

{            }ᶠ        Find all valid outputs of the predicate in brackets
               c+      Output is the sum of that list after flattening it

 >I                    Input > I
   -₂:I                The list [I-2, I]
       {   }ᵐ          Map:
        ṗ/₁              Must be prime and the output is its inverse
Fatalizar
fuente
3

MATL , 16 bytes

liqZqtd2=)t2+h/s

Pruébalo en línea!

Considere la entrada 13como un ejemplo.

l     % Push 1
      %   STACK: 1
i     % Input N
      %   STACK: 1, 13
q     % Subtract 1
      %   STACK: 1, 12
Zq    % Primes up to that
      %   STACK: 1, [2 3 5 7 11]
t     % Duplicate
      %   STACK: 1, [2 3 5 7 11], [2 3 5 7 11]
d     % Consecutive differences
      %   STACK: 1, [2 3 5 7 11], [1 2 2 4]
2=    % Compare with 2, element-wise
      %   STACK: 1, [2 3 5 7 11], [0 1 1 0]
)     % Use as logical index to select elements from array
      %   STACK: 1, [3 5]
t     % Duplicate
      %   STACK: 1, [3 5], [3 5]
2+    % Add 2, element-wise
      %   STACK: 1, [3 5], [5 7]
h     % Concatenate horizontally
      %   STACK: 1, [3 5 5 7]
/     % Divide, element-wise
      %   STACK: [0.3333 0.2 0.2 0.1429]
s     % Sum of array. Implicitly display
      %   STACK: 0.8762
Luis Mendo
fuente
2

Mathematica, 48 47 bytes

¡Gracias a JungHwan Min por guardar 1 byte!

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&

Función sin nombre que toma un entero positivo como entrada y devuelve una fracción exacta; por ejemplo, If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&[10]devuelve92/105 .

If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]prueba si ambos iyi-2 son primos, devolviendo la suma de sus recíprocos si es así y 0si no. ~Sum~{i,#-1}&luego devuelve la suma de esas contribuciones para todos los valores imenores que la entrada.

Presentación previa:

If[And@@PrimeQ@{i,g=i-2},1/i+1/g,0]~Sum~{i,#-1}&
Greg Martin
fuente
Eso sí que es espeluznante. Me doy por vencido. ⚐
LegionMammal978
Me preguntaba si "fracción exacta" significaba Mathematica :)
Greg Martin
-1 byte:If[PrimeQ/@(i&&(g=i-2)),1/i+1/g,0]~Sum~{i,#-1}&
JungHwan Min
Se puede obtener un número de precisión arbitraria agregando dos bytes N@delante del código.
JungHwan Min
Buen golf de la condición! Es cierto que Ndevuelve una aproximación decimal a un número real; sin embargo, requiere bytes adicionales para mostrar más de 6 higos sig, y no importa cuántos sig figs se muestren, sigue siendo menos preciso que la fracción misma.
Greg Martin
2

Octava, 45 bytes

@(n)sum(all(isprime(m=[h=3:n-1;h-2]))*m'.^-1)

Explicación:

m=[h=3:n-1;h-2]             generate an concatenate two ranges 3:n-1 and 1:n-3
rec=m'.^-1                  transpose and reciprocal
idx=all(isprime(m))         create a logical [0 1 ..] array  if both ranges are prime set 1 else set 0
sum1 = idx * rec            matrix multiplication(extrat elements with logical index and sum along the first dimension)
sum(sum1)                   sum along the second dimension  

¡Pruébelo en línea!

rahnema1
fuente
2

JavaScript (ES6), 67 66 bytes

Guardado 1 byte gracias a @Arnauld

f=n=>--n>1&&((p=x=>n%--x?p(x):x==1)(n)&&p(n-=2)&&1/n+++1/++n)+f(n)

Salidas falsepara caso de prueba 2, que está permitido por defecto .

Fragmento de prueba

ETHproducciones
fuente
Creo que 1/n+++1/++nguarda un byte.
Arnauld
@Arnauld Gracias. Por alguna razón, no sabía que eso +++no siempre arroja un error ...
ETHproductions
1

Jalea , 19 bytes

’ÆRḊµ_Æp=2Tịµ_2;µİS

Pruébalo en línea!

Tengo la sensación de que esto es mejorable, pero no puedo ver de inmediato cómo.

Explicación

’ÆRḊµ_Æp=2Tịµ_2;µİS
 ÆR                  Generate all primes from 2 to n inclusive
’                    Subtract 1
   Ḋ                 Remove first element
’ÆRḊ                 Generate all primes from 3 to n-1 exclusive

     _Æp             Subtract the previous prime (i.e. calculate the prime gap)
        =2           Compare to 2
          Tị         Take elements of the input where the comparison is true
     _Æp=2Tị         Filter a list of primes to the latter halves of prime pairs

             _2      Subtract 2
               ;     Append
             _2;     Append the list to the list with 2 subtracted from it
                 İ   Take reciprocals
                  S  Sum
                 İS  Take the sum of the reciprocals

Los µConnect todas estas porciones junto tubería de estilo, con cada uno tomando la salida de la anterior como su entrada.


fuente
1

Pyth - 22 21 17 bytes

Creo que la refactorización ayudará.

scL1sf.APM_MTm,tt

Test Suite .

Maltysen
fuente
1

Perl 6 , 59 51 bytes

{sum 1 «/»grep((*-(2&0)).is-prime,^$_).flatmap:{$_-2,$_}}

{sum 1 «/»grep(*.all.is-prime,(-2..*Z ^$_)).flat}

-2..* Z ^$_comprime la lista infinita -2, -1, 0, 1, ...con la lista 0, 1, ... $_-1( $_siendo el argumento de la función), produciendo la lista (-2, 0), (-1, 1), (0, 2), ..., ($_-3, $_-1). (Obviamente, ninguno de estos números menores que 3 puede estar en un par primo, pero 3..* Z 5..^$_es unos pocos bytes más largo y ninguno de los números adicionales es primo).

Los grepselecciona sólo aquellas parejas donde todos (es decir, ambos números) son primos, y los flatellos se aplana en una lista simple de números.

«/»es el hiperoperador de división; con la lista a la derecha y 1a la izquierda, convierte la lista de pares primos en sus recíprocos, que luego se suma por sum.

Sean
fuente
1

Clojure, 147 bytes

(fn[n](let[p #(if(> % 2)(<(.indexOf(for[a(range 2 %)](mod % a))0)0))](reduce +(for[a(range 2 n)](if(and(p a)(p(- a 2)))(+(/ 1 a)(/ 1(- a 2)))0)))))

Y Clojure viene último, como siempre.

Sin golf:

; Returns the primality of a number.
(defn prime? [n]
  (if (> n 2)
    (< (.indexOf (for [a (range 2 n)] (mod n a)) 0) 0)))

; Calculates the actual Brun's Constant. ' (Stupid highlighter)
(defn brunsconst [n]
  ; Adds all of the entries together
  (reduce
    +
    ; For a in range(2, n):
    (for [a (range 2 n)]
      (let [b (- a 2)]
        ; If both a and a-2 are prime:
        (if (and (prime? a) (prime? b))
          ; Place (1/a + 1/a-2) on the array, else 0
          (+ (/ 1 a) (/ 1 b)) 0)))))
clismique
fuente
0

Bash + utilidades GNU, 86 85 bytes

for((k=4;k<$1;k++,j=k-2)){ [ `factor $k $j|wc -w` = 4 ]&&x=$x+1/$k+1/$j;};bc -l<<<0$x

Pruébalo en línea!

Construye una gran expresión aritmética y luego la alimenta bc -lpara evaluarla.

Editar: se dejó por error en un par $ (...) de una versión anterior con sustitución de comando anidada; cambiado a backticks para guardar un byte.

Mitchell Spector
fuente
0

NARS APL, 216 bytes, 108 caracteres

  r←z n;h;i;k;v
  i←0⋄n-←1⋄h←1+⍳n-1⋄→B
A:k←i⊃h⋄h←k∪(0≠k∣h)/h
B:→A×⍳(⍴h)≥i+←1
  r←+/÷(v-2),v←(h=1⌽h+2)/h

esto usaría el "Crivello di Eratostene" para encontrar la sublista en 1..arg de primos de solicitud. Prueba:

  z¨2 6 10 13 100 620
0 0.5333333333 0.8761904762 0.8761904762 1.330990366 1.499970603 
  z 100000
1.672799585
RosLuP
fuente