tổng (1/số nguyên tố [i]^2)> = 1?

Question

Trong khi cố gắng đưa ra một thuật toán, tôi tình cờ gặp câu hỏi này. Nó không phải là bài tập về nhà.

Hãy để P_i = một mảng các số nguyên tố i đầu tiên. Bây giờ tôi cần nhỏ nhất i mà

Sum<n=0..i> 1/(P_i[n]*P_i[n]) >= 1. 

(nếu như i tồn tại).

Một xấp xỉ cho số nguyên tố i 'là i*log(i). Vì vậy, tôi đã thử điều này trong Java:

public static viod main(String args[]) { 
    double sum = 0.0; 
    long i = 2; 

    while(sum<1.0) { 
     sum += 1.0/(i*Math.log(i)*i*Math.log(i)); 
     i++; 
    } 

    System.out.println(i+": "+sum); 
} 

Tuy nhiên ở trên không kết thúc vì nó hội tụ đến 0,7. Tuy nhiên, 1/100000000^2 vòng tới 0.0 bằng Java, vì vậy đó là lý do tại sao nó không hoạt động. Đối với lý do tương tự nó thậm chí không hoạt động nếu bạn thay thế dòng thứ 6 với

sum += 1.0/(i*i) 

trong khi đó nên đạt 1 nếu tôi không nhầm, bởi vì số tiền nên incease nhanh hơn 1/2^i và hội tụ sau để 1 . Nói cách khác, điều này cho thấy rằng làm tròn Java làm cho tổng số không đạt được 1. Tôi nghĩ rằng tối thiểu i của vấn đề của tôi nên tồn tại.

Answer 1

Trên toán phụ của câu hỏi này, không phải là bên java:

Nếu tôi hiểu được vấn đề, không có giải pháp (không có giá trị của i).

Đối với bất kỳ tập hợp hữu hạn nào P_i của số nguyên tố {p_1, p_2, ... p_i} cho N_i là tập hợp tất cả các số nguyên lên đến p_i, {1,2,3, ..., p_i}. Tổng 1/p^2 (cho tất cả p_n trong P_i) sẽ nhỏ hơn tổng của tất cả 1/x^2 cho x trong N_i.

Tổng số 1/x^2 tends to ~1.65 nhưng vì 1 sẽ không bao giờ có trong tập hợp các số nguyên tố, số tiền bị hạn chế bởi ~ 0,65

Answer 2

Tôi đoán bạn có thể mất độ chính xác mà bạn cần khi bạn sử dụng mặc định Math.log nhân với float i. Tôi nghĩ rằng điều này có thể được xử lý bằng cách sử dụng một RoundingMode thích hợp. Vui lòng xem setRoundingMode

Answer 3

Bạn không thể sử dụng gấp đôi cho điều này vì nó không đồng bộ. Bạn nên sử dụng phân số. Tôi thấy lớp này https://github.com/kiprobinson/BigFraction

Sau đó, tôi đã cố gắng để tìm whats xảy ra:

public static void main(String args[]) { 
     BigFraction fraction = BigFraction.valueOf(1, 4); 
     int n = 10000000, status = 1, num = 3; 
     double limit = 0.4; 

     for (int count = 2; count <= n;) { 
      for (int j = 2; j <= Math.sqrt(num); j++) { 
       if (num % j == 0) { 
        status = 0; 
        break; 
       } 
      } 
      if (status != 0) { 
       fraction = fraction.add(BigFraction.valueOf(1,BigInteger.valueOf(num).multiply(BigInteger.valueOf(num)))); 

       if (fraction.doubleValue() >= limit){ 
        System.out.println("reached " + limit + " with " + count + " firsts prime numbers"); 
        limit += 0.01; 
       } 

       count++; 
      } 
      status = 1; 
      num++; 
     } 
    } 

này là có đầu ra này:

reached 0.4 with 3 firsts prime numbers 
reached 0.41000000000000003 with 4 firsts prime numbers 
reached 0.42000000000000004 with 5 firsts prime numbers 
reached 0.43000000000000005 with 6 firsts prime numbers 
reached 0.44000000000000006 with 8 firsts prime numbers 
reached 0.45000000000000007 with 22 firsts prime numbers 

Và không có gì nhiều hơn trong một phút. Tôi gỡ lỗi nó và thấy rằng nó phát triển rất chậm và chậm hơn, tôi không nghĩ rằng, nó có thể đạt đến 1 ngay cả trong vô cùng :) (nhưng không biết làm thế nào để chứng minh nó).