The Holy Grail Of Mathematics.

[modest]

Originally Posted by Don Blazys

I can't get your graph no matter how many times I click on it.

It's just an image. It's nothing interactive. I graphed it using this website:
Graphing Calculator

EDIT: in case you mean you can't see them at all, I've changed the images to jpg format which any browser can view so long as "show images" is selected in your internet browser's settings. Private message me if you have continued trouble.

Originally Posted by Don Blazys

Also I don't calculate .8818 as a "zero" but as -6501.971... , so it's probably an asymptote, and not a zero.

I believe you're correct. The site I used obviously misinterpreted that part of the function - it does look like an asymptote.

Originally Posted by Don Blazys

By the way, your LaTex rendition is almost correct, exept for the subtraction of unity at the end.

Fixed.

Originally Posted by CraigD

Here’s a way to generate a starting value for Don’s generating formula...

That is really clever thinking. I also checked it up to 500 primes successfully.

Originally Posted by CraigD

More importantly, we haven’t proven that the as given by

Plugging your 500-digit into Don's gives a value no closer to zero than Don's 25 digit approximation of x.

Originally Posted by CraigD

If modest or someone else with a working program like the one in post #28 can modify it to use the new equation (it shouldn’t be hard to differentiate, needing only the product and chain rules, and some carefulness), it would be interesting to compare A few hundred digits of the estimated zero of to my big rational number above. To 500 decimals, it’s...

Using an online derivative finder, I get,
=

((sin(x^(1/2)))^(-1)-1)^(-1) / ((π)^2 + (ln(ln(2*((2* (x^(-1) +1))^(-1) +1))))^(-1))-1

=

-(((-3*π^2*cos(√(x))*x^2-5*π^2*cos(√(x))*x-2*π^2*cos(√(x)))*ln(3*x+2)
+(3*π^2*cos(√(x))*x^2+5*π^2*cos(√(x))*x+2*π^2*cos( √(x)))*ln(x+1))*ln(ln(3*x+2)
-ln(x+1))^2+((-3*cos(√(x))*x^2-5*cos(√(x))*x-2*cos(√(x)))*ln(3*x+2)+(3*cos(√(x))*x^2
+5*cos(√(x))*x+2*cos(√(x)))*ln(x+1))*ln(ln(3*x+2)-ln(x+1))+(2*sin(√(x))^2
-2*sin(√(x)))*√(x))/(√(x)*((((6*π^4*sin(√(x))^2-12*π^4*sin(√(x))+6*π^4)*x^2
+(10*π^4*sin(√(x))^2-20*π^4*sin(√(x))+10*π^4)*x+4*π^4*sin(√(x))^2
-8*π^4*sin(√(x))+4*π^4)*ln(3*x+2)+((-6*π^4*sin(√(x))^2+12*π^4*sin(√(x))-6*π^4)*x^2
+(-10*π^4*sin(√(x))^2+20*π^4*sin(√(x))-10*π^4)*x-4*π^4*sin(√(x))^2+8*π^4*sin(√(x))
-4*π^4)*ln(x+1))*ln(ln(3*x+2)-ln(x+1))^2+(((12*π^2*sin(√(x))^2-24*π^2*sin(√(x))
+12*π^2)*x^2+(20*π^2*sin(√(x))^2-40*π^2*sin(√(x))+20*π^2)*x+8*π^2*sin(√(x))^2
-16*π^2*sin(√(x))+8*π^2)*ln(3*x+2)+((-12*π^2*sin(√(x))^2+24*π^2*sin(√(x))-12*π^2)*x^2
+(-20*π^2*sin(√(x))^2+40*π^2*sin(√(x))-20*π^2)*x-8*π^2*sin(√(x))^2+16*π^2*sin(√(x))
-8*π^2)*ln(x+1))*ln(ln(3*x+2)-ln(x+1))+((6*sin(√(x))^2-12*sin(√(x))+6)*x^2+(10*sin(√(x))^2
-20*sin(√(x))+10)*x+4*sin(√(x))^2-8*sin(√(x))+4)*ln(3*x+2)+((-6*sin(√(x))^2+12*sin(√(x))-6)*x^2
+(-10*sin(√(x))^2+20*sin(√(x))-10)*x-4*sin(√(x))^2+8*sin(√(x))-4)*ln(x+1)))

Graphing (green) and (red) gives:



Red does look like green's derivative to me. Unless it can be simplified algebraically I don't have much hope for Newton's method, but without any better ideas, I could give it a try.

Originally Posted by CraigD

From a practical computational perspective, like so many candidate prime number generators, this one’s not very useful, because in order to generate many primes, its must be very precise, and arithmetic on very precise numbers take a lot of computing time and CPU. From a math insight perspective, however, it’s wonderful if true, and a nifty (and maybe not easy) exercise to prove true or not.

I agree with both points.

~modest

[modest]

Using Newton's method with the derivative I gave above, starting at '2.56', with 125-digit accuracy, I get these results:

Iteration 1: 
2.56563060960481762248282987937393497549542054464
8286747384009513257202513484139358776541568224439
0858632748703058429949739842

Iteration 2:
2.56652456406646578056167108050564457088812861758
3395279837174966833713944002734979909689831246012
9867563762003639542486276154

Iteration 3: 
2.56654382347877558788567847718727886298307419078
8419782048165079419952931936539487288874036810064
7478513751291809498728151677

Iteration 4: 
2.56654383217242373414113906879383451033230442147
2089648153518652897650115821467896292478300260626
1634945600572639125959828278

Iteration 5: 
2.56654383217242550447509230222797944953210133882
5047777927047735001396066137472047172538770141468
7658631479727115696034317965

Iteration 6: 
2.56654383217242550447509230230139048641563711587
2170285653270636448636297384205893821843247782478
0024327177286692841095113007

Iteration 7: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178603161857601313466

Iteration 8: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389675

Iteration 9: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389648

Iteration 10: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389673

Iteration 11: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389646

Iteration 12: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389671

Iteration 13: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389644

Iteration 14: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389616

Iteration 15: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389641

Iteration 16: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389613

Iteration 17: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389638

Iteration 18: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389610

Iteration 19: 
2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
1759025178606894344698389635

I would trust this to be good to at least 100 digit accuracy making a reliable zero of the given equation, =

2.56654383217242550447509230230139048641563711587
2170285779503861302856886575848727073486249578262
175...

Plugging this into your equation, =

-0.00000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000
03484126325781802162370861802...

The first 20 results generated with the above are [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 39, 86, 107, 116, 120,
1010, 3530, 4609, 5137, 5252] which has diverged from the primes by the 11th iteration.

Sorry Don, I was really hoping this would work. I’ll post the code I used below in case the computer teachers at your school or anyone else you had working on it want to check for errors or whatnot. I should also mention that finding the root at this relatively low accuracy too over an hour. Finding a few hundred digits of the zero would no doubt take days.

To find the root:

use Math::BigFloat;

$n = 1;

my $x = Math::BigFloat->new('2.56' ,125);
my $pi = Math::BigFloat->bpi(125);

while ($n < 20) {
$fx = ((sin($x**(1/2)))**(-1)-1)**(-1) / (($pi)**2 + (log(log(2*((2* ($x**(-1) +1))**(-1) +1))))**(-1))-1;
$fprimex = -(((-3*$pi**2*cos(sqrt($x))*$x**2-5*$pi**2*cos(sqrt($x))*$x-2*$pi**2*cos(sqrt($x)))*log(3*$x+2)+(3*$pi**2*cos(sqrt($x))*$x**2+5*$pi**2*cos(sqrt($x))*$x+2*$pi**2*cos(sqrt($x)))*log($x+1))*log(log(3*$x+2)-log($x+1))**2+((-3*cos(sqrt($x))*$x**2-5*cos(sqrt($x))*$x-2*cos(sqrt($x)))*log(3*$x+2)+(3*cos(sqrt($x))*$x**2+5*cos(sqrt($x))*$x+2*cos(sqrt($x)))*log($x+1))*log(log(3*$x+2)-log($x+1))+(2*sin(sqrt($x))**2-2*sin(sqrt($x)))*sqrt($x))/(sqrt($x)*((((6*$pi**4*sin(sqrt($x))**2-12*$pi**4*sin(sqrt($x))+6*$pi**4)*$x**2+(10*$pi**4*sin(sqrt($x))**2-20*$pi**4*sin(sqrt($x))+10*$pi**4)*$x+4*$pi**4*sin(sqrt($x))**2-8*$pi**4*sin(sqrt($x))+4*$pi**4)*log(3*$x+2)+((-6*$pi**4*sin(sqrt($x))**2+12*$pi**4*sin(sqrt($x))-6*$pi**4)*$x**2+(-10*$pi**4*sin(sqrt($x))**2+20*$pi**4*sin(sqrt($x))-10*$pi**4)*$x-4*$pi**4*sin(sqrt($x))**2+8*$pi**4*sin(sqrt($x))-4*$pi**4)*log($x+1))*log(log(3*$x+2)-log($x+1))**2+(((12*$pi**2*sin(sqrt($x))**2-24*$pi**2*sin(sqrt($x))+12*$pi**2)*$x**2+(20*$pi**2*sin(sqrt($x))**2-40*$pi**2*sin(sqrt($x))+20*$pi**2)*$x+8*$pi**2*sin(sqrt($x))**2-16*$pi**2*sin(sqrt($x))+8*$pi**2)*log(3*$x+2)+((-12*$pi**2*sin(sqrt($x))**2+24*$pi**2*sin(sqrt($x))-12*$pi**2)*$x**2+(-20*$pi**2*sin(sqrt($x))**2+40*$pi**2*sin(sqrt($x))-20*$pi**2)*$x-8*$pi**2*sin(sqrt($x))**2+16*$pi**2*sin(sqrt($x))-8*$pi**2)*log($x+1))*log(log(3*$x+2)-log($x+1))+((6*sin(sqrt($x))**2-12*sin(sqrt($x))+6)*$x**2+(10*sin(sqrt($x))**2-20*sin(sqrt($x))+10)*$x+4*sin(sqrt($x))**2-8*sin(sqrt($x))+4)*log(3*$x+2)+((-6*sin(sqrt($x))**2+12*sin(sqrt($x))-6)*$x**2+(-10*sin(sqrt($x))**2+20*sin(sqrt($x))-10)*$x-4*sin(sqrt($x))**2+8*sin(sqrt($x))-4)*log($x+1)));
$x = $x - ($fx / $fprimex);

print "Iteration $n: $x \n \n";
$n += 1;
    }

To check to root:

use Math::BigFloat;

$n = 1;

my $x = Math::BigFloat->new('2.566543832172425504475092302301390486415637115872170285779503861302856886575848727073486249578262175' ,125);
my $pi = Math::BigFloat->bpi(125);

$fx = ((sin($x**(1/2)))**(-1)-1)**(-1) / (($pi)**2 + (log(log(2*((2* ($x**(-1) +1))**(-1) +1))))**(-1))-1;

print $fx;

To generate the primes:

use Math::BigFloat;

$n = 1;

my $x = Math::BigFloat->new('2.566543832172425504475092302301390486415637115872170285779503861302856886575848727073486249578262175' ,125);


while ($n < 21) {
    $n += 1;
    print int($x),"  $x \n \n ";
    $x = (($x/int($x))-1)**(-1);
    }

Output from generating primes:

2  
2.566543832172425504475092302301390486415637...
3
3.530176989714906033364148596554659995910153...
5
5.658487746918629412659711455595004495617668...
7
7.593155716863869815405210254129724962568830...
11
11.80128556631025640539791517929889399141064...
13
13.72793977888878975598933174466413738362946...
17
17.8586201455355024691937312851814766372825...
19
19.7992093341782407323601518013036272125288...
23
23.7734961135508893367847814910284223028877...
29
29.7351203154905049796724099896587367504668...
39
39.4493246736759135854493344509092908313751...
86
86.7969249962215611957434718571442165786342...
107
107.914798014555272292500524333031172756101...
116
116.965710788099919975054128977049080718021...
120
120.118778240258961127708634461338116244126...
1010
1010.28605692738992756394968843990969720229...
3530
3530.76574378238047229643409124426431277717...
4609
4609.89704549251159936514080185464580543652...
5137
5137.97799384227184795092084557134786124355...
5252
5252.58930881089776777042007289489303113638...

[Don Blazys]

To: Modest,

Well, Newtons method can be unreliable if the zero is too near an asymptote or extremum, and that derivative looks far too complicated and involved for such a simple function! I am now working on finding a simpler and more reliable derivative, because my calculation of the second root or "Prime generating constant" is:

2.566,543,832,171,7....

and thats using nothing but the "graph" function of a hand held calculator! As you can see, it is somewhat different from your calculation:

2.566,543,832,172,4.... ,

so it is clear that more reliable calculations are in order. There are many ways to determine derivatives, and I'm quite certain that I can find one that is more suitable for our purposes than the monstrosity that was presented to you by that online derivative finder.

Then, there is this to consider: Calculating the first logarithm to a large number of decimal places must rely on whatever "mechanism" is "built in" to the calculating machine or device. Thus, calculating the first logarithm to a large number of decimal places is probably the "hard part", and may require some "trial and error" work. However, calculating the second logarithm to a very high degree of accuracy can indeed be accomplished using the "Taylor series expansion of natural logarithms" because taking the first logarithm puts the value of the number in a range between +1 and -1.

By the way, I found some of my old notes on how I calculated the constant:

2.566,543,832,171,388,844,467,529...

to 24 decimal places, but I need not post it now because it is essentially the same method that CraigD used to calculate my prime generating constant to 500 decimal places.

Anyway, thanks for all the hard work that you did so far. You know, if I'm right, then it's an incredible discovery, and if I'm wrong, then it's an incredible "mathematical curiosity". Either way, the word "incredible" applies!

Don.

[Qfwfq]

Originally Posted by modest

Wouldn't it be simpler to write as follows? (I don't know what's gone wrong with the width here)





Done without pencil & paper, over many edits, but should be alright now. Now that ought to be simpler to take the derivative of.

[modest]

Originally Posted by Don Blazys

To: Modest,

Well, Newtons method can be unreliable if the zero is too near an asymptote or extremum

Yes, but it did successfully converge.

Originally Posted by Don Blazys

and that derivative looks far too complicated and involved for such a simple function!

I agree with you 100%. It, nevertheless, worked.

Originally Posted by Don Blazys

I am now working on finding a simpler and more reliable derivative,

Glad to hear it. If I were more practiced in my calculus I'd be doing the same.

Originally Posted by Don Blazys

because my calculation of the second root or "Prime generating constant" is:

2.566,543,832,171,7....

and thats using nothing but the "graph" function of a hand held calculator!

Your hand-held is off by 0.0000000000007255... It falls about half-way between your result and my result.

Originally Posted by Don Blazys

so it is clear that more reliable calculations are in order.

No, not really. You've missed the essential part. I'm not relying on the unwieldy derivative above to check the zero. I'm doing that directly. I only used the derivative to help me find the zero computationally. If you want to check my value, you can plug it directly into your equation and see how close it is to zero. I'm sure you already know this being you're much better at this sort of thing than I am. But, what you may not know is that there are many calculators available besides your hand-held that will do this for you. For example, you can use google.

Do a google search typing in these two strings exactly:

((sin((2.566543832171388844467529)^(1/2)))^(-1)-1)^(-1) / ((pi)^2 + (ln(ln(2*((2* ((2.566543832171388844467529)^(-1) +1))^(-1) +1))))^(-1))-1

((sin((2.566543832172425504475)^(1/2)))^(-1)-1)^(-1) / ((pi)^2 + (ln(ln(2*((2* ((2.566543832172425504475)^(-1) +1))^(-1) +1))))^(-1))-1

Google calculator will solve these, the first is your x and the second is mine. The results are linked here:

Google calculator with my x
Google calculator with your x

Google solves my approximated value out to and your approximated value to .

Google has greater precision than your hand-held, but not as good as PERL, yet it agrees my value is closer to the root. Others can check the result, but it looks significantly different from the value needed to generate primes with the given method.

~modest

[Don Blazys]

To: CraigD.

Wow, what a monster result! Sure beats my measly 25 digit calculation!

How much calculating time did that take?

Can you post the program so that I can show it to some of the computer teachers at my school?

Clearly, you and I think alike, and our methods of solution are similar (as demonstrated by our 25 and 500 digit calculations of my prime generating constant), but philosophically, we do tend to disagree. (Not that that's "bad"). For instance, do you expect that someone will ever find a "non-trivial zero" of the Riemann zeta function with a "real part" other than (1/2)? I don't. In the same way, I really don't see any reason why my formula should "break down", and if it does, then it is I who will be really, I mean really "wonderstruck" because that would mean that numbers with shared properties behave somewhat less "cohesively" than they should.

Thanks for all your great input so far.

Don.

[Qfwfq]

Originally Posted by Qfwfq

Wouldn't it be simpler to write as follows? (I don't know what's gone wrong with the width here)





Done without pencil & paper, over many edits, but should be alright now. Now that ought to be simpler to take the derivative of.

Even better:

[Don Blazys]

To: Feral__Squirrel,

Thanks for the kind words and interesting remarks and suggestions.

Don.

[modest]

Don,

First, let me apologize if I showed any disrespect for your knowledge in this arena and also for pointing you toward google calculator. I think I can do better on both accounts.

The function calculator at this site will help confirm my results:

Function calculator

If you input your function it can find the root to arbitrary accuracy (as well as many other useful and interesting things). Inputting your function,

((sin(x^(1/2)))^(-1)-1)^(-1) / ((pi)^2 + (ln(ln(2*((2* (x^(-1) +1))^(-1) +1))))^(-1))-1

it finds:

Root: f(2.5665438321724255044750923023013904864156371158 722)=0

which confirms my result.

I wish I had known about this site before all the coding

~modest

[CraigD]

Originally Posted by Don Blazys

Wow, what a monster result! Sure beats my measly 25 digit calculation!

How much calculating time did that take?

It took just under 6 minutes (358 sec) to calculate for . The speed of the calculation depends on the size (number of integer digits) of the numbers, so it gets slower as it proceeds: calculating for took an additional 176 sec. This is on 2004 commodity (ie: cheap) laptop, using a programming language not optimal for high-precision arithmetic (MUMPS).

I spent a couple of hours performing a few steps with the equivalent of paper and pencil, then writing the program. The program is just a strait-forward automation of the algebra of writing in terms of for each , via the formula



which always has a solution of the form



where j, k, r, and s are integers

, then solving the inequality in terms of

My program is in a less well-known language, and calls my own unlimited precision subroutines. This is it:

K P s P=2,P(2)="",J=1,K=0,M=0,N=1 f  w "(",$p(J,"/"),"*A",$p($s(K'<0:"+"_K,1:K),"/"),")/(",$p(M,"/"),"*A",$p($s(N'<0:"+"_N,1:N),"/"),")" w "  P=",P,"  " d SRM(.j,P,N),SRS(.j,j,K),SRM(.k,P,M),SRS(.k,J,k),SRA(.m,j,N),SRS(.n,k,M) w $p(j,"/"),"/",$p(k,"/")," <= A < ",$p(m,"/"),"/",$p(n,"/") r R,! s j=J,k=K,m=M,n=N d SRM(.J,P,m),SRM(.K,P,n),SRM(.M,P,m),SRM(.M,M,-1),SRA(.M,M,j),SRM(.N,P,n),SRM(.N,N,-1),SRA(.N,N,k) s P=P'=2+1+P,I=0 F  S I=$O(P(I)) S:'I P(P)=1 Q:'I  S:P#I=0 P=P+2,I=0

But I’d not expect someone unfamiliar with the MUMPS language to be able to easily read it. In pseudo code, it’s:

1. Initialize 4 integers j, k, m and n to: j=1; k=0; m=0; n=1
2. Get the nth prime number P
3. is between (P*n -k)/(P*m -j) and ((P+1)*n -k)/((P+1)*m -j). Note that the program doesn’t tell which is the lower, inclusive bound, and which the upper, exclusive one.
4. Assign new values to j, k, m and n:
   j= P*m; k= P*n;
   m= j -P*m; n= k -P*n
   (note that calculations must be simultaneous, ie: the j and k used to update m and n must be their pre-update values)
5. Repeat steps 2 – 4 until desired precision reached.

There’re some interesting math questions raised here, among them “does exist that can generate all the primes?” Note that this is a very different question than “Can be written in terms other than all of the primes?” which is what your conjecture asserted to prove by example.

The question of the existence of appears to me to be equivalent to a restatement of the Reimann hypothesis as it applies to the distribution of primes (its original description). In short, if there is no unexpectedly large gap in the distribution of the primes, then the RH is true, and exists. If such a gap exists, the RH is false, and doesn’t exists.

We can illustrate this by following the above program with the assumption that the , rather than its actual value of 11. This gives output (note that is written A in this output:

1. (1*A+0)/(0*A+1)  P=2
2/1 <= A < 3/1
2.000000000000000000000000000000 <= A < 3.000000000000000000000000000000
2. (0*A+2)/(1*A-2)  P=3
-8/-3 > A <= -10/-4
2.666666666666666666666666666666 > A <= 2.500000000000000000000000000000
3. (3*A-6)/(-3*A+8)  P=5
46/18 <= A < 54/21
2.555555555555555555555555555555 <= A < 2.571428571428571428571428571428
4. (-15*A+40)/(18*A-46)  P=7
-362/-141 > A <= -408/-159
2.567375886524822695035460992907 > A <= 2.566037735849056603773584905660
5. (126*A-322)/(-141*A+362)  P=23
8648/3369 <= A < 9010/3510
2.566933808251706737904422677352 <= A < 2.566951566951566951566951566951

Because the ranges and don’t overlap, could not exist if the first 5 primes were 2, 3, 5, 7, 23 rather than 2, 3, 5, 7, 11.

Don, you seem to having the same thought, evidenced by your question

Originally Posted by Don Blazys

For instance, do you expect that someone will ever find a "non-trivial zero" of the Riemann zeta function with a "real part" other than (1/2)? I don't.

which is another phrasing of the Riemann hypothesis. I share your belief that the RH is true, though, along with every known person in the world, I’ve not proven it.

That exists is, as I note, very different than the question of it being describable other than in terms of the primes.

The estimating technique for we’ve shown in this thread is unimpressive in the sense that, along with the generating function



all it shows is that we can generate the first n primes if we already know the first n primes.

We’ve show that for



or, the prettier



, but I’m not aware of a proof that no such expression can exist, though I’ve a strong suspicion none can. If it did, its implications would be staggering. A proof that no such expression can exists would be profound.