Cody Luo([email protected]) 2019-08-27 2019-09-01 2019-09-02 2021-04-01
Abstract:
Goldbach Conjecture Inequality 1: gold(n) < prime_pi(n)+sigma(n,0)
gold(n): the min non-negative integer makes that both n-g
and n+g
are primes
prime_pi(n): the count of primes in 1..n
sigma(n,0): the count of n.divisors()
gold(n) < prime_pi(n), while n>344
gold(n) < prime_pi(n)*4395/3449751 ≈ prime_pi(n)*0.0013, while n>57989356
Goldbach Conjecture Inequality 2: gold(n) < prime_pi(prime_pi(n)+n)
Keywords: Goldbach Conjecture; Prime Gap Inequality; prime_pi(n); sigma(n,0)
Improved Goldbach's Conjecture : Except n=344; n=22,46; n=28
,for any other positive integer n>1
,there exists g, 0=<g<prime_pi(n)
, make that both n-g
and n+g
are primes.
As n
increase from 2 to a very big integer, the peaks of gold(n) appear more and more slowly. n>344, history_peak(gold(n))/prime_pi(n)
rapidly decreasing from 75/68 (n=344)
to 300/685 (n=5131)
,1794/189274 (n=2591107)
, 4395/3449751(n=57989356)
, ..., to a decimal approaching 0.
limit(sup gold(n)/prime_pi(n),n,+oo) == 0
Define g:=gold(n)
as the min non-negative integer makes that both n-g
and n+g
are primes. so that 2*n=(n-g)+(n+g)=p+q
.
(gold(n),prime_pi(n),prime_pi(prime_pi(n)+n),n) (75,68,80, 344) ([9], 8, 10, 22) ([9], 9, 12, 28) ([15], 14,17, 46)
gold(n) < prime_pi(n)+8, while n>3
def golds(n): return [g for g in range(0,prime_pi(n)+8) if (is_prime(n-g) and is_prime(n+g))] #the slow algorithm to give glod(n): min non-negative integer make both `n-g` and `n+g` are primes def gold(n): g=0 while not((is_prime(n-g) and is_prime(n+g))): g+=1 return g """ return (g,step) g:the min non-negative integer make both `n-g` and `n+g` are primes step: the times of calling next_prime """ def xgold(n): g,step=0,0 p,q=n,n while not is_prime(p): step+=1 q=next_prime(q) g=q-n p=n-g return (g,step) golds_list=[(golds(n),prime_pi(n),n) for n in range(2,365) ] print(golds_list) for x in golds_list: if not x[0] or (x[0][0]>=x[1]): print(x)
# check Improved Goldbach's Conjecture @interact def check_Improved_Goldbach_Conjecture(n=(2..1024)): print (xgold(n),prime_pi(n),sigma(n,0),prime_pi(prime_pi(n)+n))
# sage verify.sage # verify Improved Goldbach's Conjecture n=344 g,step=xgold(n) print(n,xgold(n),prime_pi(n),sigma(n,0),prime_pi(prime_pi(n)+n)) n=2 g,step=xgold(n) peak=g while peak<1794: if(g>=peak): peak=g print(n,(g,step),prime_pi(n),sigma(n,0),prime_pi(prime_pi(n)+n)) n+=1 g,step=xgold(n)
~/github/playmath/stage12-Goldbach Conjecture$ sage verify.sage
ImprovedGoldbachConjecture.java: a Java GUI to search gold(n) in range(n,n+256) by using BigInteger.isProbablePrime(64)
Today(2019-09-01) morning, I discovered this beautiful inequality below, which shows Goldbach's Conjecture holds true for any integer n>2.
Goldbach Conjecture Inequality 1: gold(n) < prime_pi(n)+sigma(n,0)
gold(n): the min non-negative integer makes that both n-g
and n+g
are primes
prime_pi(n): the count of primes in 1..n
sigma(n,0): the count of n.divisors()
gold(n) < prime_pi(n), while n>344
gold(n) < prime_pi(n)*4395/3449751 ≈ prime_pi(n)*0.0013, while n>57989356
2019-09-02 dawn, I found:
Goldbach Conjecture Inequality 2: gold(n) < prime_pi(prime_pi(n)+n)
These two inequalities are so straightforward, which directly show you the proving process. Let's prove Inequality 2 firstly, start from
Prime Gap Inequality: p[i+1]-p[i]<=i , the i-th prime gap is less than or equal to i
, i=1,2,3,... , here p[i]=nth_prime(i).
Prove: Because we can dispatch distinct prime factors for range(p[i],p[i+1])
, the items of the range is [p[i],p[i]+1,p[i+2], ..., p[i+1]-1]
Pigeonhole Principle shows p[i+1]-p[i]<=i
, in other word, next_prime(n)-n <= prime_pi(n)
so, p[i]<=i-1 + i-2+...+1+p[1] = 2+i*(i-1)/2
for example:
i p[i] 9 23 [23, 24, 25, 26, 27, 28] [23, 2, 5, 13, 3, 7]
Now, suppose n>6, and n is composite, factor(n)=p1α1p2α2...prαr ,
sigma(n,0)=(α1+1)∗(α2+1)...∗(αr+1)
the number of primes less than n and coprime with n is j, suppose they are [q1,q2,...,qj]
then we have prime_pi(n) = r+j
,
consider [(n−1,n+1),(n−2,n+2),...,(n−x,n+x)] , for x=1,2,3,...g
, until we get a prime pair (n+g,n-g)
Now, we must can dispatch distinct prime factors for each item. Put it another way, to dispatch distinct prime factors for (n-x)*(n+x)
. Prime Gap Inequality ensures these prime be not great than prime_pi(n)+n
. Pigeonhole Principle guarantees len(s)<=prime_pi(prime_pi(n)+n)
, so
gold(n) < prime_pi(prime_pi(n)+n)
and, 2n= (n-g) + (n+g)
, Goldbach Conjecture is proved!□
@interact def prove2_goldbach_conjecture(n=input_box(default=344)): print('factor(n)=',factor(n)) p,q=n,n x=0 s,factor_list=[],[] while not (is_prime(p) and is_prime(q)): x+=1 p-=1 #p=n-x q+=1 #q=n+x s.append((p,q)) factor_list.append((factor(p),factor(q))) print(s) print(factor_list) print(n,p,q)
Now, I am trying to prove Inequality 1: gold(n) < prime_pi(n)+sigma(n,0)
step 1. construct a list sig_list
,
p,q=n,n
x=0
sig_list=[]
prev=n
while not is_prime(p):
x+=1
q+=1 #q=n+x
if is_prime(q):
p=n-x
if is_prime(p):
sig_list.append(p)
else:
prev=previous_prime(prev)
sig_list.append(prev)
else:
sig_list.append(q)
step 2. to drop sigma(n,0)
items in sig_list
, let target_list
is the rest list. Which items to pick out? For every divisor which formed of pxαx...pyαy,choose one item which formed of k∗pxαx...pyαy to drop, and keep k
contains as more different prime factors as possible. This means always do not drop n-x
(which has been marked as previous_prime(n,?) in sig_list
) but drop n+x
which contains most different prime factors.
step 3. Now, we must can dispatch distinct prime factors for each item of target_list
, Pigeonhole Principle guarantees len(target_list)<=prime_pi(n)
.
so we have,
`gold(n) < prime_pi(n)+sigma(n,0)`
Goldbach Conjecture is proved again!□
for example:
n=22 ('factor(n)=', 2 * 11, 'sigma(n,0)=', 4) ('sig_list:', [19, 24, 25, 26, 27, 28, 17, 30, 13]) ('target_list:', [(19, 2), (17, 2), (13, 2), (5^2, 3), (2 * 13, 4)]) assert tuple[0] of target_list has distinct primes! (22, 13, 31) n=46=2*23, sigma(46,0)=4 ('factor(n)=', 2 * 23) ('sig_list:', [43, 48, 49, 50, 51, 52, 41, 54, 55, 56, 57, 58, 37, 60, 31]) ('target_list:', [(43, 2), (41, 2), (37, 2), (31, 2), (7^2, 3), (3 * 17, 4), (5 * 11, 4), (3 * 19, 4), (2 * 29, 4), (2 * 5^2, 6), (2^2 * 13, 6)]) assert tuple[0] of target_list has distinct primes! (46, 31, 61) n=28 ('factor(n)=', 2^2 * 7, 'sigma(n,0)=', 6) ('sig_list:', [23, 30, 19, 32, 33, 34, 35, 36, 19]) ('target_list:', [(23, 2), (19, 2), (19, 2)]) assert tuple[0] of target_list has distinct primes! (28, 19, 37) """here 19 occurs twice, since 19 is just `n-g`,the last item of sig_list, so it doesn't matter!)"""
@interact def prove1_goldbach_conjecture(n=input_box(default=46)): print('factor(n)=',factor(n),'sigma(n,0)=',sigma(n,0)) p,q=n,n x=0 sig_list=[] prev=n while not is_prime(p): x+=1 q+=1 #q=n+x if is_prime(q): p=n-x # p=2*n-q if is_prime(p): sig_list.append(p) break else: prev=previous_prime(prev) sig_list.append(prev) else: sig_list.append(q) print('sig_list:',sig_list) target_list=[(factor(item),sigma(item,0)) for item in sig_list] target_list=sorted(target_list,key=lambda x: x[1],) target_list=target_list[:-sigma(n,0)] print('target_list:',target_list) print('assert tuple[0] of target_list has distinct primes!') print(n,p,q)
p=lambda i:nth_prime(i) i=9 range(p(i),p(i+1))
n=344 prime_pi(n+prime_pi(n))
GT[i-2,j-2]:= (nth_prime(i)+nth_prime(j))//2 , i>=j>=2
n=37 GT=[] for i in range(2,n): row=[(nth_prime(i)+nth_prime(j))//2 for j in range(2,i+1)] GT.append(row) print(row)
By observing Goldbach Triangle, we can conjecture that any even number n>=14 can be written to the sum of two primes in at least two forms. Since any integer n>=7 occurs twice or more in Complete Goldbach Triangle. If there are some sequence make that any natural number n>=3 can be written as the median of two items, the primes sequence seems to be the most ideal candidate. Because nth_prime(n) just can be defined as p[n]={min(x) satisfy x>p[n-1] && x%p[j]!=0 for j=1,2,...,n-1 }.