# Try to beat these MRB constant records!

Posted 7 years ago
549703 Views
|
83 Replies
|
13 Total Likes
|

## The MRB constant: ALL ABOARD!

POSTED BY: Marvin Ray Burns.

## Map:

• First, we have formal identities and theory for CMRB.
• Next, we have 3 primary proofs for all the listed CMRB formal identities.
• Then, at the end of this initial posting, we have world records of the maximum number of digits of CMRB computations by date.
• Then we have some hints for anyone serious about breaking my record.
• Followed by speed records,
• a program Richard Crandall wrote to check his code for the computing record number of digits
• and a conversation about whether Mathematica uses the same algorithm for computing CMRB by a couple of different methods.
• Then, for a few replies, we compute CMRB from Crandall's eta derivative formulas and see records there.
• There are three replies about "NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!" and the computation is now complete!!!!!.
• We see where I am on a 5,000,000 digit calculation. (Just recently completed!!!!!!!!!!!!)
• I describe the MRB supercomputer!!!!!! (faster than some computers with dual platinum Xeon processors) It was used for the 5,000,000 digit calculation.
• Then it comes time for the 6 million digit computation of CMRB. (put on hold, but taken up again at the end)
• We compute CMRB sum via an integral, which certifies the accuracy of CMRB calculations!!!!! (since the sum and integral are vastly different in every way they are computed)
• Then we take up the task of calculating 6,000,000 (6 million) digits of CMRB (for the fourth, fifth time, sixth, seventh time!) (will finish Thu 25 Feb 2021 06:48:06).
• We look for closed forms and find nontrivial, arbitrarily close approximations of CMRB.
• The latest updates on the MRB constant supercomputer 2 (with a GIF of it) and how I'm using it to break new records -- up to 6,500,000 digits which failed when 70.7% complete -- are in a few replies.
• On my 8th try I finally report that I successfully computed 6,000,000 digits of CMRB !
• We work at proving the accuracy of my computations.
• For a few replies, we find a few more formulas for CMRB,.
• We take up the challenge of computing 6,500,000 digits for the second time.

CMRB is defined at http://mathworld.wolfram.com/MRBConstant.html.

SEE ALSO:
Glaisher-Kinkelin Constant, Power Tower, Steiner's Problem
REFERENCES:
Burns, M. R. "An Alternating Series Involving n^(th) Roots." Unpublished note, 1999.

Burns, M. R. "Try to Beat These MRB Constant Records!" http://community.wolfram.com/groups/-/m/t/366628.

Crandall, R. E. "Unified Algorithms for Polylogarithm, L-Series, and Zeta Variants." 2012a.

Crandall, R. E. "The MRB Constant." §7.5 in Algorithmic Reflections: Selected Works. PSI Press, pp. 28-29, 2012b.

Finch, S. R. Mathematical Constants. Cambridge, England: Cambridge University Press, p. 450, 2003.

Plouffe, S. "MRB Constant." http://pi.lacim.uqam.ca/piDATA/mrburns.txt.

Sloane, N. J. A. Sequences A037077 in "The On-Line Encyclopedia of Integer Sequences."

Referenced on Wolfram|Alpha: MRB Constant
CITE THIS AS:
Weisstein, Eric W. "MRB Constant." From MathWorld--A Wolfram Web Resource. https://mathworld.wolfram.com/MRBConstant.html


I developed this informal catalog of formulas for the MRB constant with over 20 years of research and ideas from users like you.

11/14/2021 Here is a standard notation for the above mentioned

CMRB, .

CMRB = 0.18785964246206712024851793405427323005590332204; Table[
NSum[ (Sum[E^(I \[Pi] x) Log[x]^n/(n! x^n), {x, 1, Infinity}]), {n,
1, a}, WorkingPrecision -> 50] - CMRB, {a, 1, 10}]


11/01/2021: The catalog now appears complete:

g[x_] = x^(1/x); CMRB =
NSum[(-1)^k (g[k] - 1), {k, 1, Infinity}, WorkingPrecision -> 100,
Method -> "AlternatingSigns"]; a = -Infinity I; b = Infinity I;
g[x_] = x^(1/x); (v = t/(1 + t + t I);
Print[CMRB - (-I /2 NIntegrate[ Re[v^-v Csc[Pi/v]]/ (t^2), {t, a, b},
WorkingPrecision -> 100])]); Clear[a, b]
-9.3472*10^-94


Thus, we find

here.

Lest we forget, as seen in a late reply below and here.

(proofs and more example code follows)

On 10/18/2021, I found the following triad of pairs of integrals summed from -complex infinity to +complex infinity.

You can see it worked here.

In[1]:= n = {1, 25.6566540351058628559907};

In[2]:= g[x_] = x^(n/x);
-1/2 Im[N[
NIntegrate[(g[(1 - t)])/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]

Out[3]= {0.18785964246206712025, 0.18785964246206712025}

In[4]:= g[x_] = x^(n/x);
1/2 Im[N[NIntegrate[(g[(1 + t)])/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]

Out[5]= {0.18785964246206712025, 0.18785964246206712025}

In[6]:= g[x_] = x^(n/x);
1/4 Im[N[NIntegrate[(g[(1 + t)] - (g[(1 - t)]))/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]

Out[7]= {0.18785964246206712025, 0.18785964246206712025}


So, we have

as shown next.

n = 25.656654035105862855990729336074451537947705460580720486261181949\
0097321718621288009944007124739159792146480733342667100.;

g[x_] = {x^(1/x), x^(n/x)};

CMRB = NSum[(-1)^k (k^(1/k) - 1), {k, 1, Infinity},
WorkingPrecision -> 100, Method -> "AlternatingSigns"];

Print[CMRB -
NIntegrate[Im[g[(1 + I t)]/Sinh[\[Pi] t]], {t, 0, Infinity},
WorkingPrecision -> 100],
u = (-1 + t); v = t/u;
CMRB - NIntegrate[Im[g[(1 + I v)]/(Sinh[\[Pi] v] u^2)], {t, 0, 1},
WorkingPrecision -> 100],
CMRB - NIntegrate[Im[g[(1 - I v)]/(Sinh[-\[Pi] v] u^2)], {t, 0, 1},
WorkingPrecision -> 100]]

{-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}


On 10/10/2021, I found the following proper definite integral for CMRB.

As I mentioned in another message, this leads to almost identical proper integrals for CMRB and its integrated analog.

See notebook here.

On 9/29/2021 I found the following equation for CMRB (great for integer arithmetic because

(1-1/n)^k=(n-1)^k/n^k. )

So, using only integers, and sufficiently large ones in place of infinity, we can use

See

In[1]:= Timing[m=NSum[(-1)^n (n^(1/n)-1),{n,1,Infinity},WorkingPrecision->200,Method->"AlternatingSigns"]][[1]]

Out[1]= 0.086374

In[2]:= Timing[m-NSum[(-1)^n/x! (Sum[((-1 + n)^k) /(k n^(1 + k)), {k, 1, Infinity}])^ x, {n, 2, Infinity}, {x, 1,100}, Method -> "AlternatingSigns",  WorkingPrecision -> 200, NSumTerms -> 100]]

Out[2]= {17.8915,-2.2*^-197}


It is very much slower, but it can give a rational approximation (p/q), like in the following.

In[3]:= mt=Sum[(-1)^n/x! (Sum[((-1 + n)^k) /(k n^(1 + k)), {k, 1,500}])^ x, {n, 2,500}, {x, 6}];

In[4]:= N[m-mt]

Out[4]= -0.00602661

Out[5]= Rational


Compared to the NSum formula for m, we see

In[6]:= Head[m]

Out[6]= Real


On 9/19/2021 I found the following quality of CMRB.

On 9/5/2021 I added the following MRB constant integral over an unusual range.

See proof here.

On Pi Day, 2021, 2:40 pm EST, I added a new MRB constant integral.

We see many more integrals for CMRB.

We can expand into the following.

xx = 25.65665403510586285599072933607445153794770546058072048626118194\
90097321718621288009944007124739159792146480733342667100.;

g[x_] = x^(xx/
x); I NIntegrate[(g[(-t I + 1)] - g[(t I + 1)])/(Exp[Pi t] -
Exp[-Pi t]), {t, 0, Infinity}, WorkingPrecision -> 100]

(*
0.18785964246206712024851793405427323005590309490013878617200468408947\
72315646602137032966544331074969.*)


Expanding upon the previously mentioned

we get the following set of formulas that all equal CMRB:

Let

x= 25.656654035105862855990729 ...

along with the following constants (approximate values given)

{u = -3.20528124009334715662802858},

{u = -1.975955817063408761652299},

{u = -1.028853359952178482391753},

{u = 0.0233205964164237996087020},

{u = 1.0288510656792879404912390},

{u = 1.9759300365560440110320579},

{u = 3.3776887945654916860102506},

{u = 4.2186640662797203304551583} or

$u = \infty .$

Another set follows.

let x = 1 and

along with the following {approximations}

{u = 2.451894470180356539050514},

{u = 1.333754341654332447320456} or

$u = \infty$

then

See this notebook from the wolfram cloud for justification.

Also, in terms of the Euler-Riemann zeta function,

CMRB =

Furthermore, as ,

according to user90369 at StackExchange, CMRB can be written as the sum of zeta derivatives similar to the eta derivatives discovered by Crandall. Informations about ?(j)(k) please see e.g. here, formulas (11)+(16)+(19).

In the light of the parts above, where

CMRB

=

=

= as well as an internet scholar going by the moniker "Dark Malthorp" wrote:

## Primary Proof 1

CMRB=, based on

CMRB

is proven below by an internet scholar going by the moniker "Dark Malthorp."

## Primary Proof 2

denoting the kth derivative of the Dirichlet eta function of k and 0 respectively, was first discovered in 2012 by Richard Crandall of Apple Computer.

The left half is proven below by Gottfried Helms and it is proven more rigorouslyconsidering the conditionally convergent sum, below that. Then the right half is a Taylor expansion of ?(s) around s = 0.

it has been noted that "even though one has cause to be a little bit wary around formal rearrangements of conditionally convergent sums (see the Riemann series theorem), it's not very difficult to validate the formal manipulation of Helms. The idea is to cordon off a big chunk of the infinite double summation (all the terms from the second column on) that we know is absolutely convergent, which we are then free to rearrange with impunity. (Most relevantly for our purposes here, see pages 80-85 of this document, culminating with the Fubini theorem which is essentially the manipulation Helms is using.)"

## Primary Proof 3

Here is proof of a faster converging integral for its integrated analog (The MKB constant) by Ariel Gershon.

g(x)=x^(1/x), M1=

Which is the same as

because changing the upper limit to 2N + 1 increases MI by 2i/?.

MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .

Plugging in equations [5] and [6] into equation [2] gives us:

Now take the limit as N?? and apply equations [3] and [4] : He went on to note that

I wondered about the relationship between CMRB and its integrated analog and asked the following. So far I came up with

Another relationship between the sum and integral that remains more unproven than I would like is

f[x_] = E^(I \[Pi] x) (1 - (1 + x)^(1/(1 + x)));
CMRB = NSum[f[n], {n, 0, Infinity}, WorkingPrecision -> 30,
Method -> "AlternatingSigns"];
M2 = NIntegrate[f[t], {t, 0, Infinity I}, WorkingPrecision -> 50];
part = NIntegrate[(Im[2 f[(-t)]] + (f[(-t)] - f[(t)]))/(-1 +
E^(-2 I \[Pi] t)), {t, 0, Infinity I}, WorkingPrecision -> 50];
CMRB (1 - I) - (M2 - part)


gives

6.10377910^-23 - 6.10377910^-23 I.

As with any scientific paper, this post contains only reproducible results with methods. These records represent the advancement of consumer-level computers and clever programming over the past 20 years. I see others breaking these records, even after I die!

Here are some record computations. If you know of any others let me know.

• On or about Dec 31, 1998, I computed 1 digit of the (additive inverse of ) CMRB with my TI-92s, by adding 1-sqrt(2)+3^(1/3)-4^(1/4)+... as far as I could. That first digit, by the way, is just 0. Then by using the sum feature, in approximate mode, to compute $\sum _{n=1}^{1000 } (-1)^n \left(n^{1/n}\right),$ I computed the first correct decimal of $\text{CMRB}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right)$ i.e. (.1). It gave (.1_91323989714) which is close to what Mathematica gives for summing to only an upper limit of 1000.

• On Jan 11, 1999, I computed 4 decimals(.1878) of CMRB with the Inverse Symbolic Calculator, with the command evalf( 0.1879019633921476926565342538468+sum((-1)^n* (n^(1/n)-1),n=140001..150000)); where 0.1879019633921476926565342538468 was the running total of t=sum((-1)^n* (n^(1/n)-1),n=1..10000), then t= t+the sum from (10001.. 20000), then t=t+the sum from (20001..30000) ... up to t=t+the sum from (130001..140000).

• In Jan of 1999, I computed 5 correct decimals (rounded to .18786)of CMRB using Mathcad 3.1 on a 50 MHz 80486 IBM 486 personal computer operating on Windows 95.

• Shortly afterward I tried to compute 9 digits of CMRB using Mathcad 7 professional on the Pentium II mentioned below, by summing (-1)^x x^(1/x) for x=1 to 10,000,000, 20,000,000, and a many more, then linearly approximating the sum to a what a few billion terms would have given.

• On Jan 23, 1999, I computed 500 digits of CMRB with an online tool called Sigma. Remarkably the sum in 4. was correct to 6 of the 9 decimal places! See http://marvinrayburns.com/OriginalMRBPost.html if you can read the printed and scanned copy there.

• In September of 1999, I computed the first 5,000 digits of CMRB on a 350 MHz Pentium II with 64 Mb of RAM using the simple PARI commands \p 5000;sumalt(n=1,((-1)^n*(n^(1/n)-1))), after allocating enough memory.

• On June 10-11, 2003 over a period, of 10 hours, on a 450 MHz P3 with an available 512 MB RAM, I computed 6,995 accurate digits of CMRB.

• Using a Sony Vaio P4 2.66 GHz laptop computer with 960 MB of available RAM, at 2:04 PM 3/25/2004, I finished computing 8000 digits of CMRB.

• On March 01, 2006, with a 3 GHz PD with 2 GB RAM available, I computed the first 11,000 digits of CMRB.

• On Nov 24, 2006, I computed 40, 000 digits of CMRB in 33 hours and 26 min via my program written in Mathematica 5.2. The computation was run on a 32-bit Windows 3 GHz PD desktop computer using 3.25 GB of Ram. The program was something like this:

Block[{a, b = -1, c = -1 - d, d = (3 + Sqrt[8])^n,
n = 131 Ceiling[40000/100], s = 0}, a[0] = 1;
d = (d + 1/d)/2; For[m = 1, m < n, a[m] = (1 + m)^(1/(1 + m)); m++];
For[k = 0, k < n, c = b - c;
b = b (k + n) (k - n)/((k + 1/2) (k + 1)); s = s + c*a[k]; k++];
N[1/2 - s/d, 40000]]

• Finishing on July 29, 2007, at 11:57 PM EST, I computed 60,000 digits of CMRB. Computed in 50.51 hours on a 2.6 GHz AMD Athlon with 64 bit Windows XP. Max memory used was 4.0 GB of RAM.

• Finishing on Aug 3, 2007, at 12:40 AM EST, I computed 65,000 digits of CMRB. Computed in only 50.50 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 5.0 GB of RAM.

• Finishing on Aug 12, 2007, at 8:00 PM EST, I computed 100,000 digits of CMRB. They were computed in 170 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.

• Finishing on Sep 23, 2007, at 11:00 AM EST, I computed 150,000 digits of CMRB. They were computed in 330 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 22 GB of RAM. The typical daily record of memory used was 17 GB of RAM.

• Finishing on March 16, 2008, at 3:00 PM EST, I computed 200,000 digits of CMRB using Mathematica 5.2. They were computed in 845 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 47 GB of RAM. The typical daily record of memory used was 28 GB of RAM.

• Washed away by Hurricane Ike -- on September 13, 2008 sometime between 2:00 PM - 8:00 PM EST an almost complete computation of 300,000 digits of CMRB was destroyed. Computed for a long 4015. Hours (23.899 weeks or 1.4454*10^7 seconds) on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 91 GB of RAM. The Mathematica 6.0 code used follows:

Block[{$MaxExtraPrecision = 300000 + 8, a, b = -1, c = -1 - d, d = (3 + Sqrt[8])^n, n = 131 Ceiling[300000/100], s = 0}, a[0] = 1; d = (d + 1/d)/2; For[m = 1, m < n, a[m] = (1 + m)^(1/(1 + m)); m++]; For[k = 0, k < n, c = b - c; b = b (k + n) (k - n)/((k + 1/2) (k + 1)); s = s + c*a[k]; k++]; N[1/2 - s/d, 300000]]  • On September 18, 2008, computation of 225,000 digits of CMRB was started with a 2.66 GHz Core 2 Duo using 64 bit Windows XP. It was completed in 1072 hours. Memory usage is recorded in the attachment pt 225000.xls, near the bottom of this post. • 250,000 digits were attempted but failed to be completed to a serious internal error that restarted the machine. The error occurred sometime on December 24, 2008, between 9:00 AM and 9:00 PM. The computation began on November 16, 2008, at 10:03 PM EST. Like the 300,000 digit computation, this one was almost complete when it failed. The Max memory used was 60.5 GB. • On Jan 29, 2009, 1:26:19 pm (UTC-0500) EST, I finished computing 250,000 digits of CMRB. with a multiple-step Mathematica command running on a dedicated 64 bit XP using 4 GB DDR2 RAM onboard and 36 GB virtual. The computation took only 333.102 hours. The digits are at http://marvinrayburns.com/250KMRB.txt. The computation is completely documented in the attached 250000.PD at bottom of this post. • On Sun 28 Mar 2010 21:44:50 (UTC-0500) EST, I started a computation of 300000 digits of CMRB using an i7 with 8.0 GB of DDR3 RAM onboard, but it failed due to hardware problems. • I computed 299,998 Digits of CMRB. The computation began Fri 13 Aug 2010 10:16:20 pm EDT and ended 2.23199*10^6 seconds later | Wednesday, September 8, 2010. I used Mathematica 6.0 for Microsoft Windows (64-bit) (June 19, 2007) That is an average of 7.44 seconds per digit. I used my Dell Studio XPS 8100 i7 860 @ 2.80 GHz with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929 GB virtual Ram. • I computed exactly 300,000 digits to the right of the decimal point of CMRB from Sat 8 Oct 2011 23:50:40 to Sat 5 Nov 2011 19:53:42 (2.405*10^6 seconds later). This run was 0.5766 seconds per digit slower than the 299,998 digit computation even though it used 16 GB physical DDR3 RAM on the same machine. The working precision and accuracy goal combination were maximized for exactly 300,000 digits, and the result was automatically saved as a file instead of just being displayed on the front end. Windows reserved a total of 63 GB of working memory of which 52 GB were recorded being used. The 300,000 digits came from the Mathematica 7.0 command Quit; DateString[] digits = 300000; str = OpenWrite[]; SetOptions[str, PageWidth -> 1000]; time = SessionTime[]; Write[str, NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, WorkingPrecision -> digits + 3, AccuracyGoal -> digits, Method -> "AlternatingSigns"]]; timeused = SessionTime[] - time; here = Close[str] DateString[]  • 314159 digits of the constant took 3 tries due to hardware failure. Finishing on September 18, 2012, I computed 314159 digits, taking 59 GB of RAM. The digits came from the Mathematica 8.0.4 code DateString[] NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, WorkingPrecision -> 314169, Method -> "AlternatingSigns"] // Timing DateString[]  • Sam Noble of Apple computed 1,000,000 digits of CMRB in 18 days 9 hours 11 minutes 34.253417 seconds. • Finishing on Dec 11, 2012, Richard Crandall, an Apple scientist, computed 1,048,576 digits in a lightning-fast 76.4 hours computation time (from the timing command). That's on a 2.93 GHz 8-core Nehalem. • In Aug of 2018, I computed 1,004,993 digits of CMRB in 53.5 hours with 10 DDR4 RAM (of up to 3000 MHz) supported processor cores overclocked up to 4.7 GHz! Search this post for "53.5" for documentation. • Sept 21, 2018: I computed 1,004,993 digits of CMRB in 50.37 hours of absolute time (35.4 hours computation time) with 18 (DDR3 and DDR4) processor cores! Search this post for "50.37 hours" for documentation.** • On May 11, 2019, I computed over 1,004,993 digits, using 28 kernels on 18 DDR4 RAM (of up to 3200 MHz) supported cores overclocked up to 5.1 GHz in 45,5 hours of absolute time and only 32.5 hours of computation time! Search 'Documented in the attached ":3 fastest computers together 3.nb." ' for the post that has the attached documenting notebook. • On 10/19/20, using 3/4 of the MRB constant supercomputer 2, I finished an over 1,004,993 digits computation of CMRB in 44 hours of absolute time -- see https://www.wolframcloud.com/obj/bmmmburns/Published/44%20hour%20million.nb for documentation. • I computed a little over 1,200,000 digits of CMRB in 11 days, 21 hours, 17 minutes, and 41 seconds (finishing on March 31, 2013). I used a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz. • On May 17, 2013, I finished a 2,000,000 or more digit computation of CMRB, using only around 10GB of RAM. It took 37 days 5 hours 6 minutes 47.1870579 seconds. I used my six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz. • A previous world record computation of CMRB was finished on Sun 21 Sep 2014 at 18:35:06. It took 1 month 27 days 2 hours 45 minutes 15 seconds. The processor time from the 3,000,000+ digit computation was 22 days. I computed the 3,014,991 digits of CMRB with Mathematica 10.0. I Used my new version of Richard Crandall's code in the attached 3M.nb, optimized for my platform and large computations. I also used a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz with 64 GB of RAM of which only 16 GB was used. Can you beat it (in more number of digits, less memory used, or less time taken)? This confirms that my previous "2,000,000 or more digit computation" was accurate to 2,009,993 digits. they were used to check the first several digits of this computation. See attached 3M.nb for the full code and digits. • Finished on Wed 16 Jan 2019 19:55:20, I computed over 4 million digits of CMRB. It took 4 years of continuous tries. This successful run took 65.13 days computation time, with a processor time of 25.17 days, on a 3.7 GHz overclocked up to 4.7 GHz on all cores Intel 6 core computer with 3000 MHz RAM. According to this computation, the previous record, 3,000,000+ digit computation, was accurate to 3,014,871 decimals, as this computation used my algorithm for computing n^(1/n) as found in chapter 3 in the paper at https://www.sciencedirect.com/science/article/pii/0898122189900242 and the 3 million+ computation used Crandall's algorithm. Both algorithms outperform Newton's method per calculation and iteration. See attached notebook. M R Burns' algorithm: x = SetPrecision[x, pr]; y = x^n; z = (n - y)/y; t = 2 n - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (n - 1)/t2 + (n + 1) z/(2 n t) - SetPrecision[13.5, pr] n (n - 1) 1/(3 n t2 + t^3 z)); (*N[Exp[Log[n]/n],pr]*)  Example:  ClearSystemCache[]; n = 123456789; (*n is the n in n^(1/n)*) x = N[n^(1/n),100]; (*x starts out as a relatively small precision approximation to n^(1/n)*) pc = Precision[x]; pr = 10000000; (*pr is the desired precision of your n^(1/n)*) Print[t0 = Timing[While[pc < pr, pc = Min[4 pc, pr]; x = SetPrecision[x, pc]; y = x^n; z = (n - y)/y; t = 2 n - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pc] (n - 1)/t2 + (n + 1) z/(2 n t) - SetPrecision[13.5, pc] n (n - 1)/(3 n t2 + t^3 z))]; (*You get a much faster version of N[n^(1/n),pr]*) N[n - x^n, 10]](*The error*)]; ClearSystemCache[]; n = 123456789; Print[t1 = Timing[N[n - N[n^(1/n), pr]^n, 10]]]  Gives  {25.5469,0.*10^-9999984} {101.359,0.*10^-9999984}  R Crandall's algorithm: While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^n - n; x = x (1 - 2 y/((n + 1) y + 2 n n));]; (*N[Exp[Log[n]/ n],pr]*)  Example:  ClearSystemCache[]; n = 123456789; (*n is the n in n^(1/n)*) x = N[n^(1/n)]; (*x starts out as a machine precision approximation to n^(1/n)*) pc = Precision[x]; pr = 10000000; (*pr is the desired precision of your n^(1/n)*) Print[t0 = Timing[While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^n - n; x = x (1 - 2 y/((n + 1) y + 2 n n));]; (*N[Exp[Log[n]/n],pr]*) N[n - x^n, 10]](* The error*)]; Print[ t1 = Timing[N[n - N[n^(1/n), pr]^n, 10]]]  Gives  {32.1406,0.*10^-9999984} {104.516,0.*10^-9999984}  More information available upon request. • Finished on Fri 19 Jul 2019 18:49:02, I computed over 5 million digits of CMRB. Methods described in the reply below that starts with "Attempts at a 5,000,000 digit calculation ." For this 5 million calculation of MRB using the 3 node MRB supercomputer: processor time was 40 days. and the actual time was 64 days. That is faster than the 4 million digit computation using just one node. • I finally computed 6,000,000 digits of the MRB constant after 8 tries in 19 months. (Search "8/24/2019 It's time for more digits!" below.) finishing on Tue 30 Mar 2021 22:02:49 in 160 days. The MRB constant supercomputer 2 said the following: Finished on Tue 30 Mar 2021 22:02:49. Processor and actual time were 5.2881585937510^6 and 1.3893572053630110^7 s. respectively Enter MRB1 to print 6029991 digits. The error from a 5,000,000 or more digit calculation that used a different method is 0.*10^-5024993 That means that the 5,000,000 digit computation Was actually accurate to 5024993 decimals!!! Also, beyond any shadow of a doubt, I verified 5,609,880 digits of the MRB constant on Thu 4 Mar 2021 08:03:45. The 5,500,000+ digit computation using a totally different method showed that many decimals are in common with the 6,000,000+ digit computation. Here is my mini-cluster of the fastest 3 computers (the MRB constant supercomputer 0) mentioned below: The one to the left is my custom-built extreme edition 6 core and later with an 8 core Xeon processor. The one in the center is my fast little 4 core Asus with 2400 MHz RAM. Then the one on the right is my fastest -- a Digital Storm 6 core overclocked to 4.7 GHz on all cores and with 3000 MHz RAM. Answer 83 Replies Sort By: Posted 7 years ago  If the discussion, looks likeright above this, you might have to refresh the page to see the first message.The following might help anyone serious about breaking my record.Richard Crandall wrote about couple of new formulae for computing the MRB constant faster on pp 28 and 29 here. By the way, I wrote Crandall about formula (44) -- it seems it should have a minus sign in front of it -- and he wrote back: Answer Posted 7 years ago  The following email Crandall sent me before he died might be useful for anyone checking their results: Answer Posted 7 years ago  Perhaps some of these speed records will be easier to beat.The ultimate speed record to beat, though, is Ricahrd Crandall's (Chief cryptographer for Apple, 2012) 1,048,576 digits in a blistering fast 76.4 hours, while the Apple computation group(also in 2012) computed 1,000,000 digits of the MRB constant in a long 18 days 9 hours 11 minutes 34.253417 seconds, so progress vs time is not as linear as my results plotted above. Answer Posted 7 years ago  I found the following program Crandall wrote to check his code. (It gives the MRB constant to the desired level of precision.) It's hard to follow! But here it is: t1 = 1/2 (2 EulerGamma Log[2] - Log[2]^2); t2 = 1/24 (\[Pi]^2 Log[2]^2 - 2 \[Pi]^2 Log[ 2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 6 (Zeta^\[Prime]\[Prime])[2]); FLAG = 1; prec = 200;$MaxPrecision = Infinity; expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.3 pr]; Print[n]; d = N[(3 + Sqrt[8])^n, prec]; d = 1/2 (d + 1/d); {b, c, s} = {-1, -d, 0}; T0 = T00 = SessionTime[]; Do[c = b - c; s = s + c*N[E^(Log[k + 1]/(k + 1)) - 1 - FLAG * (Log[k + 1]/(k + 1) + 1/2! Log[k + 1]^2/(k + 1)^2), pr]; (* s=s+c*N[(k+1)^(1/(k+1))-1,pr]; *) b = (k + n) (k - n) b/((k + 1) (k + 1/2)); If[Mod[k, 1000] == 0, Print[{k, SessionTime[] - T0}]; T0 = SessionTime[]], {k, 0, n - 1}]; N[-s/d, pr]]; (*Begin test to given precision.*) (*t1=Timing[MRBtrue=NSum[(-1)^n*(n^(1/n)-1),{n,1,Infinity},\ WorkingPrecision\[Rule]prec,Method\[Rule]"AlternatingSigns"];];*) t3 = Timing[MRBtest = expM[prec];] SessionTime[] - T00 MRBtest + FLAG * (t1 + t2) 
Posted 7 years ago

## A missing post, that is commented on bellow, follows.

c1 = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 200,
PrecisionGoal -> 200];

c2 = NSum[(2 k)^(1/(2 k)) - (2 k - 1)^(1/(2 k - 1)), {k, 1, Infinity},
WorkingPrecision -> 600, PrecisionGoal -> 600, NSumTerms -> 2^22];
c1 - c2


gives -6.6444030376101061743388604*10^-173 While, if you try it naively,

NSum[(-1)^n*(n^(1/n) - 1), {n, 1, \[Infinity]},
Method -> "AlternatingSigns", WorkingPrecision -> 100,
PrecisionGoal -> 100] -
N[Sum[(2 k)^(1/(2 k)) - (2 k - 1)^(1/(2 k - 1)), {k,
1, \[Infinity]}], 100]


you get 8.65025879128817600921262272409653679780852599347660397129681915033728\ 91*10^-28, with only 28 digits of accuracy!

Attachments:
Posted 7 years ago
 It is hard to be certain that c1 and c2 are correct to 77 digits even though they agree to that extent. I'm not saying that they are incorrect and presumably you have verified this. Just claiming that whatever methods NSum may be using to accelerate convergence, there is really no guarantee that they apply to this particular computation. So c1 aand c2 could agree to that many places because they are computed in a similar manner without all digits actually being correct.
Posted 7 years ago
 C1, the approximation to and a special case of , is computed correctly by Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier,s Convergence Acceleration of Alternating Series as found next. Below it is computed by Newton's method using their acceleration "Algorithm 1" to at least 1000 decimals.  (* Newer loop with Newton interior. *) prec = 1000;(*Number of required decimals.*) expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.32 pr]; Print["Iterations required: ", n]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {-1, -d, 0}; T0 = SessionTime[]; Do[c = b - c; x = N[E^(Log[k + 1]/(k + 1)), iprec = Ceiling[prec/128]]; pc = iprec; Do[nprec = Min[2 pc, pr]; x = SetPrecision[x, nprec];(*Adjust precision*) x = N[x - x/(k + 1) + 1/x^k, nprec]; pc *= 2; If[nprec >= pr, Break[]], {ct, 1, 19}]; s += c*(x - 1); b *= 2 (k + n) (k - n)/((k + 1) (2 k + 1)); If[Mod[k, 1000] == 0, Print["Iterations: ", k, " Cumulative time (sec): ", SessionTime[] - T0];], {k, 0, n - 1}]; N[-s/d, pr]]; MRBtest2 = expM[prec] During evaluation of In[17]:= Iterations required: 1320During evaluation of In[17]:= Iterations: 0 Cumulative time (sec): 0.*10^-8During evaluation of In[17]:= Iterations: 1000 Cumulative time (sec): 0.1872004Out[18]= 0. 1878596424620671202485179340542732300559030949001387861720046840894772 3156466021370329665443310749690384234585625801906123137009475922663043 8929348896184120837336626081613602738126379373435283212552763962171489 3217020762820621715167154084126804483635416719985197680252759893899391 4457983505561350964852107120784442309586812949768852694956420425558648 3670441042527952471060666092633974834103115781678641668915460034222258 8380025455396892947114212218910509832871227730802003644521539053639505 5332203470627551159812828039510219264914673176293516190659816018664245 8249506972033819929584209355151625143993576007645932912814517090824249 1588320416906640933443591480670556469280678700702811500938060693813938 5953360657987405562062348704329360737819564603104763950664893061360645 5280675151935082808373767192968663981030949496374962773830498463245634 7931157530028921252329181619562697369707486576547607117801719578736830 0965902260668753656305516567361288150201438756136686552210674305370591 0397357561914891They are the same as found from the methods Mathematica uses:  c1 = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, \[Infinity]}, Method -> "AlternatingSigns", WorkingPrecision -> 100, PrecisionGoal -> 100] 0.18785964246206712024851793405427323005590309490013878617200468408947 723156466021370329665443310750
Posted 7 years ago
 For c1 I used a method for alternating series to get a very precise sum approximation: That is from the "AlternatingSigns" option.
Posted 7 years ago
 One more record, Richard Crandall was the first one to compute 319,000 digits of the MRB constant in one day*, as early as Nov 24, 2012. Here is a portion of his email:*He may have been counting CPU time alone (from the Timing[] comand which is an under estimate of the actual time taken).. My personal records are in actual time taken.
Posted 7 years ago
 Above where Cohen said, the coefficients of the numerators are furthered below. I know the pattern for the first and last coefficient of each line, but can you figure out a simple pattern for the rest of them? My hat's off to you if you can! 2 16, 8 98, 80, 32 576, 544, 384, 128 3362, 3312, 2912, 1792, 512 19600, 19528, 18688, 15104, 8192, 2048 114242, 114144, 112576, 103168, 76288, 36864, 8192 665856, 665728, 663040, 641536, 557056, 376832, 163840, 32768 3880898, 3880736, 3876416, 3832064, 3603968, 2945024, 1826816, 720896, 131072 
Posted 7 years ago

## Tue 24 Apr 2018

Here are some timings from version 11.3 and my first custom built computer with it's two separate processors:

[41]

## Sat 28 Apr 2018

Chapter 3 in the paper at https://www.sciencedirect.com/science/article/pii/0898122189900242 , gives a 4th degree convergence rate algorithm for the nth root of x, which I used to add a new interior to my version of Crandall's MRB constant computation program, making it a hybrid. As the paper describes the algorithm, it is best used for getting many digits from a sufficiently precise initial term. (I used Crandall's 3rd degree convergence interior to get the sufficiently precise term.) This algorithm better optimizes my program for large calculations a little according to the following:

Here is a table of the results so far, which also show that RAM speed is the most important factor in a computer for computing the MRB constant!:

Here are a timing table with All MRB method, Crandall's method and a hybrid of the two on this 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB ram DDR4, 2TB SATA in Windows 10 Pro:

Here are the 3 programs referenced in the above table:

# All MRB:

 Print["Start time is " "Start time is ", ds = DateString[], "."];
prec = 10000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[1.0002 pre]}, chunksize = cores*tsize;
n = Floor[1.32 pr];
end = Ceiling[n/chunksize];
Print["Iterations required: ", n];
Print["Will give ", end,
" time estimates, each more accurate than the previous."];
Print["Will stop at ", end*chunksize,
" iterations to ensure precsion of around ", pr,
" decimal places."]; d = ChebyshevT[n, 3];
{b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
iprec = pr/2^6;
Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];
pc = iprec;

While[pc < pr, pc = Min[4 pc, pr];
x = SetPrecision[x, pc];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =    x*(1 + SetPrecision[4.5, pc] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
2 pc] ll (ll - 1)/ (3 ll t2 + t^3 z))];(**N[Exp[Log[
ll]/ll],pr]**)

x, {l, 0, tsize - 1}], {j, 0, cores - 1},
Method ->
"EvaluationsPerKernel" ->
16(*a power of 2 commensurate with available RAM*)]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}],
Method ->
"EvaluationsPerKernel" ->
16(*a power of 2 commensurate with processor strength*)];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-10)*(n)/(3600)/(24);
If[kc > 1,
Print[kc, " iterations done in ", N[st - stt, 4], " seconds.",
" Should take ", N[ti, 4], " days or ", ti*3600*24,
"s, finish ", DatePlus[ds, ti], "."],
Print["Denominator computed in  " , stt = st, "s."]];, {k, 0,
end - 1}];
N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ",
DateString[], ". Processor and total time were ",
t2[[1]], " and ", st, " s respectively."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ",
Floor[Precision[
MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]


# Crandall

Print["Start time is ", ds = DateString[], "."];
prec = 100000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*=4*
number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
n = Floor[1.32 pr];
end = Ceiling[n/chunksize];
Print["Iterations required: ", n];
Print["Will give ", end,
" time estimates, each more accurate than the previous."];
Print["Will stop at ", end*chunksize,
" iterations to ensure precsion of around ", pr,
" decimal places."]; d = ChebyshevT[n, 3];
{b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
iprec = Ceiling[pr/27];
Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];
pc = iprec;
While[pc < pr, pc = Min[3 pc, pr];
x = SetPrecision[x, pc];
y = x^ll - ll;
x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/
ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1},
Method ->
"EvaluationsPerKernel" ->
64(*a power of 2 commensurate with processor strength*)]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}],
Method ->
"EvaluationsPerKernel" ->
16(*a power of 2 commensurate with processor strength*)];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
If[kc > 1,
Print[kc, " iterations done in ", N[st, 3], " seconds.",
" Should take ", N[ti, 2], " days or ", N[ti*24*3600, 2],
"s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ",
DateString[], ". Processor time was ",
t2[[1]], " s. Actual time was ", SessionTime[] - T0, "."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ",
Floor[Precision[
MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]


# Hybrid

Print["Start time is ", ds = DateString[], "."];
prec = 300000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
n = Floor[1.32 pr];
end = Ceiling[n/chunksize];
Print["Iterations required: ", n];
Print["Will give ", end,
" time estimates, each more accurate than the previous."];
Print["Will stop at ", end*chunksize,
" iterations to ensure precsion of around ", pr,
" decimal places."]; d = ChebyshevT[n, 3];
{b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
iprec = Ceiling[pr/27];
Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];
pc = iprec;
While[pc < pr/4, pc = Min[3 pc, pr/4];
x = SetPrecision[x, pc];
y = x^ll - ll;
x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/
ll],pr/4]**)x = SetPrecision[x, pr];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**
N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0,
cores - 1},
Method ->
"EvaluationsPerKernel" ->
32(*a power of 2 commensurate with available RAM*)]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}],
Method ->
"EvaluationsPerKernel" ->
16(*a power of 2 commensurate with processor strength*)];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
If[kc > 1,
Print[kc, " iterations done in ", N[st, 4], " seconds.",
" Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4],
"s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ",
DateString[], ". Proccessor time was ", t2[[1]], " s."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ",
Floor[Precision[
MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]


## Aug 8 2018

I've been having great success with the Wolfram Lightweight Grid and "threadpriority," like in the following:

 In[23]:= Needs["SubKernelsLocalKernels"]
Block[{$mathkernel =$mathkernel <> " -threadpriority=2"},
LaunchKernels[]]

Out[24]= {"KernelObject"[43, "burns"], "KernelObject"[44, "burns"],
"KernelObject"[45, "burns"], "KernelObject"[46, "burns"],
"KernelObject"[47, "burns"], "KernelObject"[48, "burns"],
"KernelObject"[49, "burns"], "KernelObject"[50, "burns"],
"KernelObject"[51, "local"], "KernelObject"[52, "local"],
"KernelObject"[53, "local"], "KernelObject"[54, "local"],
"KernelObject"[55, "local"], "KernelObject"[56, "local"]}


.

I just now computed 1,004,754 digits of the MRB constant in 58 hours of absolute time!

I think that worked because my computer with the local kernels is the faster one.

See attached "58 hour million."

Aug 9, 2018, I just now computed 1,004,993 digits of the MRB constant in 53.5 hours of absolute time! Summarized below.

Print["Start time is ", ds = DateString[], "."];
prec = 1000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
n = Floor[1.32 pr];
end = Ceiling[n/chunksize];
Print["Iterations required: ", n];
Print["Will give ", end,
" time estimates, each more accurate than the previous."];
Print["Will stop at ", end*chunksize,
" iterations to ensure precsion of around ", pr,
" decimal places."]; d = ChebyshevT[n, 3];
{b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
iprec = Ceiling[pr/6912];
Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];

pc = iprec;
While[pc < pr/1024, pc = Min[3 pc, pr/1024];
x = SetPrecision[x, pc];
y = x^ll - ll;
x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];
(**N[Exp[Log[ll]/ll],pr/1024]**)

x = SetPrecision[x, pr/256];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
ll]/ll],pr/256]*)

x = SetPrecision[x, pr/64];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/64]**)

x = SetPrecision[x, pr/16];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/16]**)

x = SetPrecision[x, pr/4];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/4]**)

x = SetPrecision[x, pr];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/
ll],pr]*)

x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}], Method -> "Automatic"];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
Print[kc, " iterations done in ", N[st, 4], " seconds.",
" Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4],
"s, finish ", DatePlus[ds, ti], "."], {k, 0, end - 1}];
N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ",
DateString[], ". Proccessor time was ",
t2[[1]], " s."]; Print["Actual time was ", st];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ",
Floor[Precision[
MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]


Start time is Wed 8 Aug 2018 14:09:15.

Iterations required: 1326598

Will give 648 time estimates, each more accurate than the previous.

Will stop at 1327104 iterations to ensure precsion of around 1004999 decimal places.

0 iterations done in 259.9 seconds. Should take 3.991*10^7 days or 3.448*10^12s, finish Fri 24 Dec 111294 02:34:55.

2048 iterations done in 523.6 seconds. Should take 3.926 days or 3.392*10^5s, finish Sun 12 Aug 2018 12:22:00.

4096 iterations done in 790.2 seconds. Should take 2.962 days or 2.559*10^5s, finish Sat 11 Aug 2018 13:14:46.

6144 iterations done in 1058. seconds. Should take 2.645 days or 2.285*10^5s, finish Sat 11 Aug 2018 05:38:01.

8192 iterations done in 1329. seconds. Should take 2.490 days or 2.152*10^5s, finish Sat 11 Aug 2018 01:55:27.

10240 iterations done in 1602. seconds. Should take 2.402 days or 2.075*10^5s, finish Fri 10 Aug 2018 23:47:32.

12288 iterations done in 1875. seconds. Should take 2.343 days or 2.024*10^5s, finish Fri 10 Aug 2018 22:22:49.

14336 iterations done in 2151. seconds. Should take 2.304 days or 1.990*10^5s, finish Fri 10 Aug 2018 21:26:34.

16384 iterations done in 2424. seconds. Should take 2.272 days or 1.963*10^5s, finish Fri 10 Aug 2018 20:41:04.

18432 iterations done in 2700. seconds. Should take 2.250 days or 1.944*10^5s, finish Fri 10 Aug 2018 20:08:36.

20480 iterations done in 2977. seconds. Should take 2.232 days or 1.928*10^5s, finish Fri 10 Aug 2018 19:42:40.

22528 iterations done in 3256. seconds. Should take 2.219 days or 1.917*10^5s, finish Fri 10 Aug 2018 19:24:31.

24576 iterations done in 3533. seconds. Should take 2.207 days or 1.907*10^5s, finish Fri 10 Aug 2018 19:07:43.

26624 iterations done in 3811. seconds. Should take 2.198 days or 1.899*10^5s, finish Fri 10 Aug 2018 18:53:53.
...

1320960 iterations done in 1.921*10^5 seconds. Should take 2.232 days or 1.929*10^5s, finish Fri 10 Aug 2018 19:43:46.

1323008 iterations done in 1.923*10^5 seconds. Should take 2.232 days or 1.929*10^5s, finish Fri 10 Aug 2018 19:43:28.

1325056 iterations done in 1.926*10^5 seconds. Should take 2.232 days or 1.928*10^5s, finish Fri 10 Aug 2018 19:43:08.

Finished on Fri 10 Aug 2018 19:39:26. Proccessor time was 122579. s.

Actual time was 192609.7247443

Enter MRBtest2 to print 1004992 digits

If you saved m3M, the difference between this and 3,014,991 known digits is 0.*10^-1004993


## Sept 21, 2018, I just now computed 1,004,993 digits of the MRB constant in 50.37 hours of absolute time (35.4 hours processor time)! See attached "50 hour million."

Here is a table of my speed progress in computing the MRB constant since 2012:

See attached "kernel priority 2 computers.nb" and "3 fastest computers together.nb" for some documentation of the timings in the last 2 columns, respectively. See "3million 2 computers" for the estimated time of 24 days for computing 3,000,000 digits.

## 01/08/2019

Here is an update of 100k digits (in seconds): Notice, I broke the 1,000 second mark!!!!!

Attachments:
Posted 7 years ago
 What Richard Crandall and maybe others did to come up with that method is really good and somewhat mysterious. I still don't really understand the inner workings, and I had shown him how to parallelize it. So the best I can say is that it's really hard to compete against magic. (I don't want to discourage others, I'm just explaining why I myself would be reluctant to tackle this. Someone less familiar might actually have a better chance of breaking new ground.)In a way this should be good news. Should it ever become "easy" to compute, the MRB number would lose what is perhaps its biggest point of interest. It just happens to be on that cusp of tantalizingly "close" to easily computable (perhaps as sums of zeta function and derivatives thereof), yet still hard enough that it takes a sophisticated scheme to get more than a few dozen digits.
Posted 7 years ago
 Daniel Lichtblau, Which one do you not understand? how he derived the eta' formula: from ?Or is it how and why he added the extra loop to Cohen's method:ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); ?I've been asking for a proof of the eta formula derivation. I think it could become the foundation to a great paper.If the extra loop changes Cohen's method for to a method for I think the code in that loop could help prove the derivation.
Posted 7 years ago
 I can't say I understand either. My guess is the Eta stuff comes from summing (-1)^k*(Log[k]/k)^n over k, as those are the terms that appear in the double sum you get from expanding k^(1/k)-1 in powers of Log[k]/k (use k^(1/k)=Exp[Log[k]/k] and the power series for Exp). Even if it does come from this the details remain elusive..
Posted 7 years ago
 Daniel Lichtblau and others, Richard Crandall did intend to explian his work on the MRB constant and his program to compute it. When I wrote him with a possible small improvement to his program he said, "It's worth observing when we write it up." See screenshot:
Posted 7 years ago
 Crandall is not using his eta formulas directly!!!!!!! He computes Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}] directly!Going back to Crandall's code: (*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 500000;(*Number of \ required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; MRBtest2 - MRBtest3 x = N[E^(Log[ll]/(ll)), iprec]; Gives k^(1/k) to only 1 decimal place; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0).. On the other hand, While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));], takes the short precision x and gives it the necessary precision and accuracy for k^(1/k) (k Is ll there.) It actually computes k^(1/k). Then he remarks, "(N[Exp[Log[ll]/ll], pr])."After finding a fast way to compute k^(1/k) to necessary precision he uses Cohen's algorithm 1 (See a screenshot in a previous post.) to accelerate convergence of Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}]. That is his secret!!As I mentioned in a previous post the "MRBtest2 - MRBtest3" is for checking with a known-to-be accurate approximation to the MRB constant, MRBtest3I'm just excited that I figured it out! as you can tell.
Posted 7 years ago
 Nice work. Worth a bit of excitement, I' d say.
Posted 7 years ago
 Richard Crandall might of had some help in developing his method. He wrote one time: "Marvin I am working on a highly efficient method for your constant, and I've been in touch with other mathematics scholars.Please be patient...recSent from my iPhone."
Posted 7 years ago
 The result of k^(1/k) from the iteration in Crandall's code grows like the following example of 123^(1/123).. Timing[ll = 123; x = 1 + 1/10; Table[Block[{$MaxExtraPrecision = Infinity}, x = SetPrecision[x, 20 + a^6]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll)); N[ll^(1/ll) - x, a + 20]], {a, 1, 13}]] That gives the following timing and accuracies per iteration.  {8.829657, {-0.04239426367665370783, -0.02519017014329854597401, \ -0.0097174389047505410455275, -0.000933400633967433388167272, \ -9.456045144810702667437515*10^-7, \ -9.8570302819631224677862339*10^-16, \ -1.11649387558952636447488240*10^-42, \ -1.622508976729293063326569833*10^-123, \ -4.9794273187141078980478269830*10^-366, \ -1.43931637321260733551982880202*10^-1093, \ -3.476056847637409626605825363818*10^-3276, \ -4.8964202322309104109089811118496*10^-9824, \ -1.36852937628135955635109182098985*10^-29467}} Here is a more extreme example from my big computer where we get about 64,000,000 digits of accuracy of 123^(1/123) in only 20 iterations! In[47]:= Timing[ll = 123; x = 1 + 1/10; Table[Block[{$MaxExtraPrecision = Infinity}, x = SetPrecision[x, 20 + a^6]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll)); N[ll^(1/ll) - x, a + 20]], {a, 1, 20}]] Out[47]= {210.180147, {-0.04239426367665370783, \ -0.02519017014329854597401, -0.0097174389047505410455275, \ -0.000933400633967433388167272, -9.456045144810702667437515*10^-7, \ -9.8570302819631224677862339*10^-16, \ -1.11649387558952636447488240*10^-42, \ -1.622508976729293063326569833*10^-123, \ -4.9794273187141078980478269830*10^-366, \ -1.43931637321260733551982880202*10^-1093, \ -3.476056847637409626605825363818*10^-3276, \ -4.8964202322309104109089811118496*10^-9824, \ -1.36852937628135955635109182098985*10^-29467, \ -2.987998984519890677800153644718129*10^-88398, \ -3.1099929855547029560727524646233719*10^-265190, \ -3.50668133180579791324881778853196092*10^-795566, \ -5.026977910888395698424738167604170974*10^-2386694, \ -1.4809452514436132712292881458571004047*10^-7160077, \ -3.78647491015226246115034702337662410645*10^-21480228, 0.*10^-64000020}} Furthermore this process can compute 6,379,358,787 digits of the Sqrt[2], from an initial guess of machine precision, in 18 iterations: In[90]:= Timing[ll = 2; x = 2.^(1/2); Table[Block[{$MaxExtraPrecision = Infinity}, x = SetPrecision[x, 20 + a^7.5]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll)); N[ll^(1/ll) - x, a + 20]], {a, 1, 18}]] Out[90]= {1913.882668, {0.*10^-21, -1.800462644283455490473*10^-148, \ -7.2956225729359623776786*10^-445, \ -4.85397000370369097837099*10^-1334, \ -1.429556345255675471801415*10^-4001, \ -3.6518576944392011682818847*10^-12004, \ -6.08767627470915271802076570*10^-36012, \ -2.820100999650988078782491560*10^-108035, \ -2.8035222068968058313783728204*10^-324105, \ -2.75436831997714080172674040062*10^-972315, \ -2.612017346393607427831858236332*10^-2916945, \ -2.2276049962448401256762035120120*10^-8750835, \ -1.38173437723345455709717486529180*10^-26252505, \ -3.297491628267321222864512567028780*10^-78757516, \ -4.4818892212256882776648121052875660*10^-236272548, \ -1.12536490316593766234907240580868063*10^-708817643, 0.*10^-1073741813, 0.*10^-1073741813}} The above pattern is 3 times the previous number of accurate digits per iteration.. 708817643 * 3^2= 6379358787 I believe it will only take 191+16 = 207 iterations to compute a google digits of the Sqrt[2]: In[55]:= Log[10.^100/708817643]/Log[3] Out[55]= 191.04  Answer Posted 7 years ago ## Jan 2015 How about computing the MRB constant from Crandall's eta derivative formulas? They are mentioned in a previous post but here they are again: I computed and checked 500 digits, using the first eta derivative formula in 38.6 seconds. How well can you do? Can you improve my program? (It is a 51.4% improvement of one of Crandall's programs.) I would like a little competition in some of these records! (That formula takes just 225 summands, compared to 10^501 summands using -1^(1/1)+2^(1/2)-3^(1/3)+.... See http://arxiv.org/pdf/0912.3844v3.pdf for more summation requirements for other summation methods.) In[37]:= mm = 0.187859642462067120248517934054273230055903094900138786172004684089\ 4772315646602137032966544331074969038423458562580190612313700947592266\ 3043892934889618412083733662608161360273812637937343528321255276396217\ 1489321702076282062171516715408412680448363541671998519768025275989389\ 9391445798350556135096485210712078444230958681294976885269495642042555\ 8648367044104252795247106066609263397483410311578167864166891546003422\ 2258838002545539689294711421221891050983287122773080200364452153905363\ 9505533220347062755115981282803951021926491467317629351619065981601866\ 4245824950697203381992958420935515162514399357600764593291281451709082\ 4249158832041690664093344359148067055646928067870070281150093806069381\ 3938595336065798740556206234870432936073781956460310476395066489306136\ 0645528067515193508280837376719296866398103094949637496277383049846324\ 5634793115753002892125232918161956269736970748657654760711780171957873\ 6830096590226066875365630551656736128815020143875613668655221067430537\ 0591039735756191489093690777983203551193362404637253494105428363699717\ 0244185516548372793588220081344809610588020306478196195969537562878348\ 1233497638586301014072725292301472333336250918584024803704048881967676\ 7601198581116791693527968520441600270861372286889451015102919988536905\ 7286592870868754254925337943953475897035633134403826388879866561959807\ 3351473990256577813317226107612797585272274277730898577492230597096257\ 2562718836755752978879253616876739403543214513627725492293131262764357\ 3214462161877863771542054231282234462953965329033221714798202807598422\ 1065564890048536858707083268874877377635047689160983185536281667159108\ 41219342016438600025850842655643500695483283012054619321661.\ 273833491444; In[30]:= Timing[ etaMM[m_, pr_] := Module[{a, d, s, k, b, c}, a[j_] := Log[j + 1]^m/(j + 1)^m; n = Floor[1.32 pr]; d = Cos[n ArcCos[3]]; {b, c, s} = {-1, -d, 0}; Do[c = b - c; s = s + c a[k]; b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}]; N[s/d, pr] (-1)^m]; eta[s_] := (1 - 2^(1 - s)) Zeta[s]; eta1 = Limit[D[eta[s], s], s -> 1]; MRBtrue = mm; prec = 500; MRBtest = eta1 - Sum[(-1)^m etaMM[m, prec]/m!, {m, 2, Floor[.45 prec]}]; MRBtest - MRBtrue] Out[30]= {36.831836, 0.*10^-502}  Here is a short table of computation times with that program: Digits Seconds 500 36.831836 1000 717.308198 1500 2989.759165 2000 3752.354453  I just now retweaked the program. It is now Timing[etaMM[m_, pr_] := Module[{a, d, s, k, b, c}, a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr]; n = Floor[1.32 pr]; d = Cos[n ArcCos[3]]; {b, c, s} = {-1, -d, 0}; Do[c = b - c; s = s + c a[k]; b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}]; Return[N[s/d, pr] (-1)^m]]; eta[s_] := (1 - 2^(1 - s)) Zeta[s]; eta1 = Limit[D[eta[s], s], s -> 1]; MRBtrue = mm; prec = 1500; MRBtest = eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, Floor[.45 prec]}, Method -> "Procedural"]; MRBtest - MRBtrue]  ## Feb 2015 Here are my best eta derivative records: Digits Seconds 500 9.874863 1000 62.587601 1500 219.41540 2000 1008.842867 2500 2659.208646 3000 5552.902395 3500 10233.821601  That is using V10.0.2.0 Kernel. Here is a sample Timing[etaMM[m_, pr_] := Module[{a, d, s, k, b, c}, a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr]; n = Floor[1.32 pr]; d = Cos[n ArcCos[3]]; {b, c, s} = {-1, -d, 0}; Do[c = b - c; s = s + c a[k]; b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}]; Return[N[s/d, pr] (-1)^m]]; eta[s_] := (1 - 2^(1 - s)) Zeta[s]; eta1 = Limit[D[eta[s], s], s -> 1]; MRBtrue = mm; prec = 500; MRBtest = eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, Floor[.45 prec]}]; ] N::meprec: Internal precision limit$MaxExtraPrecision = 50. reached while evaluating
-Cos[660 ArcCos[3]].

N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating -Cos[660 ArcCos[3]]. N::meprec: Internal precision limit$MaxExtraPrecision = 50. reached while evaluating
-Cos[660 ArcCos[3]].

General::stop: Further output of N::meprec will be suppressed during this calculation.

Out[1]= {9.874863, Null}


## Aug 2016

V 11 has a significant improvement in my new most recently mentioned fastest program for calculating digits of the MRB constant via the eta formula, Here are some timings:

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275

10,000        53667.6315476


From an previous message that starts with "How about computing the MRB constant from Crandall's eta derivative formulas?" here are my first two sets of records to compare with the just mentioned ones. You can see that I increased time efficiency by 10 to 29 to even 72 fold for select computations! In the tests used in that "previous message," 4000 or more digit computations produced a seemingly indefinitely long hang-on.

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453

Digits        Seconds
500          9.874863
1000        62.587601
1500        219.41540
2000       1008.842867
2500       2659.208646
3000       5552.902395
3500       10233.821601


Comparing first of the just mentioned 2000 digit computations with the "significant improvement" one we get the following.

3752/127 ~=29.

And from the slowest to the fastest 1500 digit run we get

2989/42 ~=72,

Posted 7 years ago
 I figured out how to rapidly compute AND CHECK a computation of the MRB constant! (The timing given is in processor time [for computing and checking] only. T0 can be used with another SessionTime[] call at the end to figure out all time expired during running of the program.) I used both of Crandall's methods for computing it and used for a check, the nontrivial identity ,where gamma is the Euler constant and M is the MRB constant.Below is my first version of the code with results. If nothing else, I thought, the code pits Crandall's 2 methods against each other to show if one is wrong they both are wrong. (So it is not a real proof.) But these are two totally different methods! (the first of which has been proven by Henry Cohen to be theoretically correct here). For a second check mm is a known approximation to the constant; over 3 million non checked (as of now) digits are found in the attached file 3M.nb. (You will have to change the Format/Style to Input to use the digits.) In[15]:= (*MRB constant computation with verification! The constant's \ decimal approximation is saved as MRBtest*)prec = 5000;(*Number of \ required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize;, {k, 0, end - 1}]; etaMs = N[-s/d - (EulerGamma Log[2] - Log[2]^2/2), pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["The MRB constant was computed and checked to ", prec, " digits \ in ", t1 = t2[[1]] + Timing[eta[s_] := (1 - 2^(1 - s)) Zeta[s]; eta1 = Limit[D[eta[s], s], s -> 1]; MRBtrue = mm; MRBtest = eta1 + etaMs; check = MRBtest - MRBtrue][[1]], " seconds"]; check During evaluation of In[15]:= The MRB constant was computed and checked to 5000 digits in 2.12161 seconds Out[18]= 0.*10^-5000 In[19]:= MRBtest - mm Out[19]= 0.*10^-5000  Attachments:
Posted 7 years ago
 The identity in question is straightforward. Write n^(1/n) as Exp[Log[n]/n], take a series expansion at 0, and subtract the first term from all summands. That means subtracting off Log[n]/n in each summand. This gives your left hand side. We know it must be M - the sum of the terms we subtracted off. Now add all of them up, accounting for signs. Expand[Sum[(-1)^n*Log[n]/n, {n, 1, Infinity}]] (* Out[74]= EulerGamma Log[2] - Log[2]^2/2 *) So we recover the right hand side.I have not understood whether this identity helps with Crandall's iteration. One advantage it confers, a good one in general, is that it converts a conditionally convergent alternating series into one that is absolutely convergent. From a numerical computation point of view this is always good.
Posted 7 years ago
 Daniel Lichtblau and others, I just deciphered an Identity Crandall used for checking computations of the MRB constant just before he died. It is used in a previous post about checking, where I said it was hard to follow. The MRB constant is B here. B= In input form that is  B= Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] + 1/24 (\[Pi]^2 Log[2]^2 - 2 \[Pi]^2 Log[ 2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 6 (Zeta^\[Prime]\[Prime])[2]) + 1/2 (2 EulerGamma Log[2] - Log[2]^2) For 3000 digit numeric approximation, it is B=NSum[((-1)^( k + 1) (-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - Log[1 + k]^2/(2 (1 + k)^2))), {k, 0, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 3000] + 1/24 (\[Pi]^2 Log[2]^2 - 2 \[Pi]^2 Log[ 2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 6 (Zeta^\[Prime]\[Prime])[2]) + 1/2 (2 EulerGamma Log[2] - Log[2]^2) It is anylitaclly straight forward too because Sum[(-1)^(k + 1)*Log[1 + k]^2/(2 (1 + k)^2), {k, 0, Infinity}] gives 1/24 (-\[Pi]^2 (Log[2]^2 + EulerGamma Log[4] - 24 Log[2] Log[Glaisher] + Log[4] Log[\[Pi]]) - 6 (Zeta^\[Prime]\[Prime])[2]) That is I wonder why he chose it?
Posted 7 years ago
 The new sum is this. Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] That appears to be the same as for MRB except now we subtract two terms from the series expansion at the origin of k^(1/k). For each k these terms are Log[k]/k + 1/2*(Log[k]/k)^2. Accounting for the signs (-1)^k and summing, as I did earlier for just that first term, we get something recognizable. Sum[(-1)^(k)*(Log[k]/(k) + Log[k]^2/(2*k^2)), {k, 1, Infinity}] (* Out[21]= 1/24 (24 EulerGamma Log[2] - 2 EulerGamma \[Pi]^2 Log[2] - 12 Log[2]^2 - \[Pi]^2 Log[2]^2 + 24 \[Pi]^2 Log[2] Log[Glaisher] - 2 \[Pi]^2 Log[2] Log[\[Pi]] - 6 (Zeta^\[Prime]\[Prime])[2]) *) So what does this buy us? For one thing, we get even better convergence from brute force summation, because now our largest terms are O((logk/k)^3) and alternating (which means if we sum in pairs it's actually O~(1/k^4) with O~ denoting the "soft-oh" wherein one drops polylogarithmic factors).How helpful is this? Certainly it cannot hurt. But even with 1/k^4 size terms, it takes a long time to get even 40 digits, let alone thousands. So there is more going on in that Crandall approach.
Posted 7 years ago
 If you copy and paste the code for Zeta''[2] you get a non evaluable input!I get the following results comparing two methods: In[655]:= Timing[MRBtrue = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> prec, Method -> "AlternatingSigns"]][[1]] Out[655]= 8.049652 In[656]:= Timing[B = NSum[((-1)^(k + 1) (-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - Log[1 + k]^2/(2 (1 + k)^2))), {k, 0, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 3000] + 1/24 (\[Pi]^2 Log[2]^2 - 2 \[Pi]^2 Log[ 2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 6 (Zeta''[2])) + 1/2 (2 EulerGamma Log[2] - Log[2]^2)][[1]] Out[656]= 12.277279 
Posted 7 years ago
 Daniel Lichtblau,Notice Log[k]/(k) and Log[k]^2/(2k^2) are of the form Log[k]^n/(nk^n). We can take that summing of Log[k]/(k) + Log[k]^2/(2*k^2)+... to its end and write B= or compute NSum[(-1)^(k)*(k^(1/k) - 1 + Sum[Log[k]^n/(n*k^n), {n, 1, Infinity}]), {k, 1, Infinity}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"] - NSum[(-1)^(1 + k) Log[(k - Log[k])/k], {k, 1, Infinity}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"] Simplified,.B=,What does that do to our "better convergence from brute force summation?"P.S. I only used 2 terms in my sample data, so I might not have the correct pattern for Log[k]/(k) + Log[k]^2/(2*k^2)+... .The reason that I suspect that I've got the wrong pattern is, in the following code the summands Log[k]/(k) and Log[k]^2/(2k^2) give 0 where the Log[k]^n/(nk^n).for n>2 does not. (etaMM[m, n] Gives a numeric approximation for the mth derivative of m.)  etaMM[m_, pr_] := Module[{a, d, s, k, b, c}, a[j_] := Log[j + 1]^m/(j + 1)^m; n = Floor[1.32 pr]; d = Cos[n ArcCos[3]]; {b, c, s} = {-1, -d, 0}; Do[c = b - c; s = s + c a[k]; b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}]; Return[N[s/d, pr] (-1)^m]]; Table[-Sum[(-1)^m*etaMM[m, 30]/m!, {m, 1, a}] - Sum[(-1)^(k)*(Sum[Log[k]^n/(n*k^n), {n, 1, a}]), {k, 1, Infinity}], {a, 1, 15}] 
Posted 7 years ago
 I could really use your opinions here! If your getting tired of my posts let me know.Power towers are defined below. See http://mathworld.wolfram.com/PowerTower.html . ;;; How about breaking my record for computing the infinite power tower of the MRB constant. Here's how I have to go about computing n digits of it: I compute a decimal expansion of the MRB constant, which I save as m. Then I compute l = Log[m]; N[-ProductLog[-l]/l, n]. My record is 3 million digits, in which I used my 3,014,991 digit computation of the MRB constant (mentioned in the first post of this thread) for m.It would be EXTREMELY helpful if anyone could find a way to compute the exact power tower without first computing the MRB constant! Such a revelation would be synonymous with finding a closed for solution to the MRB constant! I've been trying to find the exact power tower, lately, with no success. Even a high precision approximation to the power tower would generate a nearly equally precise approximation to the MRB constant. (Let ll be the infinite power tower of m, then ll^(1/ll)=m)Attached are 3 million digits of the power tower.
Posted 7 years ago
 The next active post starts out with "NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!"
Posted 7 years ago
 The MRB constant is now a Scholar subject: https://scholar.google.com/scholar?q=%22MRB+constant%22
Posted 7 years ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .Attachments are still here, though. Attachments:
Posted 7 years ago
 Try to beat these MRB constant records!
Posted 3 years ago
 nice system!
Posted 3 years ago

# Talking about the eta formula for the MRB constant

Here is another great improvement in calculating digits of MRB though this first Crandall eta formula found in the psu.edu paper Unified algorithms for polylogarithm, L-series, and zeta variants

From an even earlier message that starts with "How about computing the MRB constant from Crandall's eta derivative formulas?" here are my first two sets of records to compare with the just mentioned ones. You can see that I increased time efficiency by 10 to 29 to even 72 fold for select computations! In the tests used in that "previous message," 4000 or more digit computations produced a seemingly indefinitely long hang-on.

Until mentioned otherwise, the following tables are results from my 3.4 GHz Xeon with 64 GB 1666 MHz RAM.

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453

Digits        Seconds
500          9.874863
1000        62.587601
1500        219.41540
2000       1008.842867
2500       2659.208646
3000       5552.902395
3500       10233.821601


Comparing first of the just mentioned 2000 digit computations with the "significant improvement" one, we get the following.

3752/127 ~=29.

And from the slowest to the fastest 1500 digit run we get

2989/42 ~=72,

Here is an example calculating 1500 digits in less than 23 seconds. First calculate known accurate digits:

mTrue = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 2000];


Then use this program:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] :=
Module[{a, s, k, b, c}, a[j_] := (Log[j + 1]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to


The larger prec (precission) you want to choose, the smaller number you can replace .365 with in
ParallelSum[(Cos[Pi m]) etaMM[m, prec]/N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}. For prec=5000, change .365 to .31 (approximately). This advantage for smaller upper limits being needed in the sum is due to the Gamma (!) in the denominator. On my big computer 4000 digits now gives a timing of around 1800 seconds (1/2 an hour). See message above the previous occurrence of 8/13/2017 for previous records and records before those.

V 11 has a significant improvement in my new most recently mentioned fastest program for calculating digits of the MRB constant via the eta formula, Here are some timings:

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275

10,000        53667.6315476


## UPDATE 5/30/2018

I made some programming improvements to my code for the eta formula computation of the MRB constant.

Here is the new code:

In[88]:= mTrue =
NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 5000];

In[82]:= prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to

During evaluation of In[82]:= 0.*10^-1500

Out[87]= 15.4875433


Here is a comparison of my eta formula speed records:

Here is the code for 10,000 digits:

prec = 10000;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
N[Gamma[m + 1], prec], {m, 2, Floor[.295 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to

0.*10^-9999

20621.99102


I tried a little something I got from the Mathematica documentation center. It speed the calculations up just a little more. My newest sample code as of 5/31/2018:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]},
Method -> "CoarsestGrained"];
Print[mTrue - MRBtest]; SessionTime[] - to


That leads to the following table.

See attached "eta may 31 2018.nb" for the work.

## May 31 2018 | 9:00PM EST

I tried this form using the ParallelCombine command:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = eta1 -
Total[ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.365 prec]],
Method -> "CoarsestGrained"]];
Print[mTrue - MRBtest];

SessionTime[] - to


, which lead to this remarkable set of results from my fast 4 core machine with 2400 MHz DDR4 RAM:

The code and computations from Crandall's original code and my first improvement of it can be found by searching for the post above that begins with

"How about computing the MRB constant from Crandall's eta derivative formulas?"

See eta may 31 2018.nb attachment for more work.

## UPDATE 2:51PM, June 1, 2018

**Last night at about 9:30PM EST, I started a 20,000 digit calculation of the digits of the MRB constant via eta derivatives using the "Combine" method.

## UPDATE

The 20,000 digits finished at Fri 1 Jun 2018 21:11:49 -- it took 83728.3439962 sec -- see attached 20 k eta style.nb .

That timing of 83728.3439962 sec for 20,000 digits fits perfectly with a pattern compared of previous timings. approx 5000 digits took 548sec. 10000 digits took 6806sec.

6806sec(6806sec/548sec) = 84528.532* sec.

That surprises me because my choice in the multiple of prec, as in Floor[.365 prec] for prec=20000 was only a guess. (I used 0.285.) which means the program took 5700 iterations. (It got 3.5 digits per iteration.) My plan was to always use the minimum number of iterations to get a desired number of digits.

As I wrote above:

The larger prec (precission) you want to choose, the smaller number you can replace .365 with in ParallelSum[(Cos[Pi m]) etaMM[m, prec]/N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}. For prec=5000, change .365 to .31 (approximately). This advantage for smaller upper limits being needed in the sum is due to the Gamma (!) in the denominator. On my big computer 4000 digits now gives a timing of around 1800 seconds (1/2 an hour). See message above the previous occurrence of 8/13/2017 for previous records and records before those.

I posted some about 12 kernels:

I hoped to produce some extra success by lying to Kernel Configuration as follows:

Which did lead to the following, great results:

Here is a sample:

prec = 10000;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.295 prec]],
Method -> "CoarsestGrained"]];
Print[mTrue - MRBtest];

SessionTime[] - to


During evaluation of In[52]:= 0.*10^-10000

Out[58]= 3413.3092082


See attached 16 socalled cores.nb.

There is an example of the results for using more and more kernels on my 8 duel core Zeon: -- in attached "more and more kernels effect.nb ."

## I would be absolutely delighted if anyone with a larger kernel limit license could run it and show us what your results are!!!

Here is a sample of using more and more kernels on my 8 duel core Zeon:

 Quit[];
mTrue =  0.18785964246206712024851793405427323005590309490013878617200468408947\
7231564660213703296654433107496903842345856258019061231370094759226630\
4389293488961841208373366260816136027381263793734352832125527639621714\
8932170207628206217151671540841268044836354167199851976802527598938993\
9144579835055613509648521071207844423095868129497688526949564204255586\
4836704410425279524710606660926339748341031157816786416689154600342222\
5883800254553968929471142122189105098328712277308020036445215390536395\
0553322034706275511598128280395102192649146731762935161906598160186642\
4582495069720338199295842093551516251439935760076459329128145170908242\
4915883204169066409334435914806705564692806787007028115009380606938139\
3859533606579874055620623487043293607378195646031047639506648930613606\
4552806751519350828083737671929686639810309494963749627738304984632456\
3479311575300289212523291816195626973697074865765476071178017195787368\
3009659022606687536563055165673612881502014387561366865522106743053705\
9103973575619148909369077798320355119336240463725349410542836369971702\
4418551654837279358822008134480961058802030647819619596953756287834812\
3349763858630101407272529230147233333625091858402480370404888196767676\
0119858111679169352796852044160027086137228688945101510291998853690572\
8659287086875425492533794395347589703563313440382638887986656195980733\
5147399025657781331722610761279758527227427773089857749223059709625725\
6271883675575297887925361687673940354321451362772549229313126276435732\
1446216187786377154205423128223446295396532903322171479820280759842210\
6556489004853685870708326887487737763504768916098318553628166715910841\
2193420164386000258508426556435006954832830120546193205155935040023508\
3512613359217408970073297842771289673651619602250771173880842623256978\
8546537869046222708567487474709306935732666859085616282375386551243297\
5647464914619179575869342996208149878536663170197264534260468378010759\
0551486787190395783150604524441907570445113820585333984692194828794764\
8657593178595816527492977822095977440911371434216929624593175324537340\
1299593995004917912983680848547143925846704238528608320053664510586678\
1511964596760791964317343076715344983004971288694016566004270621110790\
5316472150455632994388400521115239016877311545696102836920503689610880\
6031603660382896533239383524154510137534165673472607464891120088099838\
1520466954150263770355732835929966306427173051589721163519991611359546\
7031540872528724399819787250274679738863889705686743537785798105855619\
2492185716949135673462704077491448799682065482817465880642236348160780\
9507770579393134958298066028252721284916888092303252902700599177550596\
1583591999319086939303973661164651485821997292533710676873868623504791\
5879737968269847878082223410618789674667450680064404065553875213281494\
9807002098581322206201090112659034497174108010632475647128346095492843\
7006514745021822612041564393030885982642625682812609249113673396723593\
3714534216902560140050169469983875907342920361729301531400405936246406\
78140077947561307736973240992352946479458077816460769624086460;
Quiet[Table[LaunchKernels[1]; prec = 3000;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec];
n = Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.365 prec]],
Method -> "CoarsestGrained"]];
Print["Error was ", mTrue - MRBtest, ", using"];

Print[xx, "  kernels, and gave a time of ", SessionTime[] - to,
" s."], {xx, 1, 16}]]

  Error was 0.*10^-3000, using

1  kernels, and gave a time of 477.9303673 s.

Error was 0.*10^-3000, using

2  kernels, and gave a time of 257.3167709 s.

Error was 0.*10^-3000, using

3  kernels, and gave a time of 181.8228406 s.

Error was 0.*10^-3000, using

4  kernels, and gave a time of 147.4913411 s.

Error was 0.*10^-3000, using

5  kernels, and gave a time of 118.8902094 s.

Error was 0.*10^-3000, using

6  kernels, and gave a time of 103.5240060 s.

Error was 0.*10^-3000, using

7  kernels, and gave a time of 92.3546592 s.

Error was 0.*10^-3000, using

8  kernels, and gave a time of 85.5143638 s.

Error was 0.*10^-3000, using

9  kernels, and gave a time of 75.6869920 s.

Error was 0.*10^-3000, using

10  kernels, and gave a time of 72.1320176 s.

Error was 0.*10^-3000, using

11  kernels, and gave a time of 68.4291460 s.

Error was 0.*10^-3000, using

12  kernels, and gave a time of 62.7524163 s.

Error was 0.*10^-3000, using

13  kernels, and gave a time of 63.8671114 s.

Error was 0.*10^-3000, using

14  kernels, and gave a time of 61.3992399 s.

Error was 0.*10^-3000, using

15  kernels, and gave a time of 61.0743278 s.

Error was 0.*10^-3000, using

16  kernels, and gave a time of 60.1936369 s.


I just updated the attachment, "more and more kernels effect.nb ."

## UPDATE July 29, 2018

Here are some new stats:

## 12/31/2018

Ending this year, I subscribed to a cloud service and used a 48 core Xeon Platinum server to compare with my old 8 core Xeon that I sold, and got the following results for MRB constant computations using only Crandall's eta formula.

Here is the code used on that Intel Xeon Platinum 48 core computer, for 10,000 digits in less than 1426 seconds:

prec = 10000;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.298 prec]],
Method -> "CoarsestGrained"]];
Export["accuracy.dat",mTrue - MRBtest];

Export["time.dat",SessionTime[] - to]


## 3/27/2019

I ran an improved version of the above code (Cradall first eta formula) for 10,000 digits of MRB using 48 Mma kernels on 1 node (24 cores) of IU's Carbonate supercomputer.

configuration:

code:

Iprec = 10000;
to = SessionTime[];
etaMM[m_, pr_] :=
Module[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.295 prec]],
Method -> "CoarsestGrained"]];
Print[N[MRBtest2 - MRBtest, 10]];

SessionTime[] - to


output:

 0.*10^-10000

1333.552401


That 1333 seconds is a new speed record for 10,000 digits via eta derivatives!

Attachments:
Posted 3 years ago

## 02/12/2019

Using my 2 nodes of the MRB constant supercomputer (3.7 GH overclocked up to 4.7 GH, Intel 6core, 3000MH RAM,and 4 cores from my 3.6 GH, 2400MH RAM) I computed 34,517 digits of the MRB constant using Crandall's first eta formula:

prec = 35000;
to = SessionTime[];
etaMM[m_, pr_] :=
Block[{a, s, k, b, c},
a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.250 prec]],
Method -> "CoarsestGrained"]];
Print[N[MRBtest2 - MRBtest,10]];

SessionTime[] - to


giving -2.166803252*10^-34517 for a difference and 208659.2864422 seconds or 2.415 days for a timing.

Where MRBtest2 is 36000 digits computed through acceleration methods of n^(1/n)

## 3/28/2019

Here is an updated table of speed eta formula records:

## 04/03/2019

Using my 2 nodes of the MRB constant supercomputer (3.7 GH overclocked up to 4.7 GH, Intel 6core, 3000MH RAM,and 4 cores from my 3.6 GH, 2400MH RAM) I computed 50,000 digits of the MRB constant using Crandall's first eta formula in 5.79 days.

 prec = 50000;
to = SessionTime[];
etaMM[m_, pr_] :=
Module[{a, s, k, b, c},
a[j_] :=
SetPrecision[SetPrecision[Log[j + 1]/(j + 1), prec]^m, prec];
{b, c, s} = {-1, -d, 0};
Do[c = b - c;
s = s + c a[k];
b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n =
Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest =
eta1 - Total[
ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
N[Gamma[# + 1], prec]) &, Range[2, Floor[.245 prec]],
Method -> "CoarsestGrained"]];
Print[N[MRBtest2 - MRBtest, 10]];

SessionTime[] - to

(* 0.*10^-50000

500808.4835750*)

Posted 3 years ago

# NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!

.

.

## First effort, Sep 04, 2015

At 10:00 PM Friday Sept 04, 2015 I started the 4,000,000 run of the MRB constant proper. Does anyone want to work on it with me?

Here is the code I am using:

(*Fastest (at MRB's end) as of 24 dEC 2014.*)
Block[{$MaxExtraPrecision = 50}, prec = 4000000;(*Number of required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 16, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = Cos[n ArcCos[3]]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; h = Log[ll]/ll; x = N[Exp[h], iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 4]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 2]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Difference from 3014991 known digits is ", MRBtest2 - m3M]; MRBtest2]  3014991 digits are saved as m3M. I will post several updates as edits here as I go. EDIT: As of Sat, Sept 5, 2015, the program is indicating that the run will take 3.3 months. EDIT: Having to run the program for over 3 months, there is a chance that I would suffer a power outage longer than the 15 minutes or so that my battery backup will run my computer! Of course I'll keep you posted if that happens. (I've tried calculations that took longer than that before!) ...Updates were installed closing Mathematica.. ## Second effort, Sept 10, 2015 EDIT I didn't know that upgrading to Windows 10 caused my Windows update option to read, automatically install updates, so my computer restarted. I started the 4,000,000 digit run again at 8:34 PM, Thursday Sept 10, 2015. This time I made sure the deffer updates option was chosen!! EDIT As of Sept 19,2015, the program says it will take 94 more days to complete the 4 million digit run. EDIT As of Sept 23,2015, 9:20 PM, the program says it will take 90.9563 more days to complete the 4 million digit run. EDIT As of Sept 27,2015, 9:20 PM, the program says it will take 86.9283 more days to complete the 4 million digit run ...Updates were installed closing Mathematica.. ## Third effort, Sept 28,2015 Well I started the 4 million digit search again. This time I installed the Windows 10 Fall Creators Update to try to avoid the automatic restarts! Per my habit above I will post updates in this message. The code I'm using is the same mentioned twice above that starts with The Windows 10 Fall Creators Update restarted my machine on Thursday, Nov 16, 2017 at 5:33 pm! ## Fourth effort, Dec 19, 2017 I applied some new update policies via LogMeIn, for windows to download but not apply updates. That should work! The new run looks like  1 : 15 : 58 pm EST | Sunday, December 17, 2017 ... done iter 96256 165140.1164436.  Then  (165140.1164436) sec/(96256 iterations) (5306880 iterations)/(3600sec/hour)/(24 hour/day)  gives 105.378 day. Entering "December 17, 2017+106 days" into Wolfram Alpha tells us the computation should be done around Monday, April 2, 2018. My computer went to sleep sometime between 10:15:51 pm EST | Thursday, December 28, 2017 and 9:22:00 am EST | Sunday, December 31, 2017 . ## Fifth effort, Jan 09, 2018 The output starts out with "Sun 7 Jan 2018 15:14:50" Iterations required: 5306398 end 3455 5306880 done iter 0 2374.6810043.  The latest result is done iter 92160 153642.6180409. Entering  (153642.6180409) sec/(92160 iterations) (5306880iterations)/(3600 sec/hour)/(24 hour/day)  gives 102.399 day or 3.4 months for the computation to run. Here is the latest output: done iter 3048960 5.1636602440434*10^6. N[3048960/5306880*100] says the computation is 57.453% done. ... My computer failed on 3/11/2018 at 8:30 am. I will break the program up, where it does a little at a time and saves a file with what progress has been made! ## Sixth effort, Sat 14 Apr 2018 I optimized my program to calculating 4019999 digits with my new system in Mathematica v. 11.3 (not kernel version). Posted below. On my new Xeon system, this optimized version gives V11.3 (not kernel version) a slight advantage over 11.2 (not kernel version)! Print["Start time is ", ds = DateString[], "."]; prec = 4000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*=4*number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/ ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st, 3], " seconds.", " Should take ", N[ti, 2], " days or ", N[ti*24*3600, 2], "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \ output*); Print["Enter MRBtest2 to print ", Floor[Precision[ MRBtest2]], " digits"]; Print["If you saved m3M, the difference \ between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]  I'm going to play around with it an see what my patience and my computer's endurance amounts to. Here is the result: Start time is Sat 14 Apr 2018 14:00:33. Iterations required: 5306398 Will give 1296 time estimates, each more accurate than the previous. Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places. 4096 iterations done in 1.1810^4 seconds. Should take 1.810^2 days or 1.5*10^7s, finish Tue 9 Oct 2018 01:49:36. ... 2789376 iterations done in 4.21*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 07:21:24. That is 43.92 days from now (9:15:15 am EDT | Saturday, June 2, 2018). ... My computer crashed! ## Seventh! effort 27 Aug 2018 I started another 4 million digit run with my 3.7 GH overclocked up to 4.7 GH, Intel 6core and 6 kernels at 3000MH RAM, w/ 4 cores and 8 kernels of 3.6 GH at 2400MH RAM with optimized use of kernel priority. It is ultra fast!!!!!! Instead of around 100 days it says it will be done in less than 50 days. Here are the results thus far: Print["Start time is ", ds = DateString[], "."]; prec = 4000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/24768]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4096, pc = Min[3 pc, pr/4096]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/4096]**) x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/1024]*) x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/256]*) x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/64]**) x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/16]**) x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/4]**) x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/ ll],pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s, finish ", DatePlus[ds, ti], "."], {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Actual time was ", st]; (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \ output*); Print["Enter MRBtest2 to print ", Floor[Precision[ MRBtest2]], " digits"]; Print["If you saved m3M, the difference \ between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]  Start time is Mon 27 Aug 2018 17:22:11. Iterations required: 5306398 Will give 2592 time estimates, each more accurate than the previous. Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places. 0 iterations done in 1408. seconds. Should take 8.646*10^8 days or 7.470*10^13s, finish Sun 25 Jul 2369306 03:19:20. 2048 iterations done in 2831. seconds. Should take 84.90 days or 7.335*10^6s, finish Tue 20 Nov 2018 14:58:22. 4096 iterations done in 4261. seconds. Should take 63.90 days or 5.521*10^6s, finish Tue 30 Oct 2018 14:52:54. 6144 iterations done in 5752. seconds. Should take 57.49 days or 4.967*10^6s, finish Wed 24 Oct 2018 05:12:32. 8192 iterations done in 7237. seconds. Should take 54.26 days or 4.688*10^6s, finish Sat 20 Oct 2018 23:35:31. ... 210944 iterations done in 1.513*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:53:41. 212992 iterations done in 1.528*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:49:24. 215040 iterations done in 1.543*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:48:16. 217088 iterations done in 1.558*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:04:29. 219136 iterations done in 1.573*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:07:25. ... 548864 iterations done in 3.954*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:06:24. 550912 iterations done in 3.968*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:08:05. 552960 iterations done in 3.983*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:09:03. ... 782336 iterations done in 5.655*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:52:31. 784384 iterations done in 5.671*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 03:00:20. 786432 iterations done in 5.685*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:58:41. ... 907264 iterations done in 6.568*10^5 seconds. Should take 44.46 days or 3.841*10^6s, finish Thu 11 Oct 2018 04:26:21. 909312 iterations done in 6.583*10^5 seconds. Should take 44.46 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:29:41. 911360 iterations done in 6.598*10^5 seconds. Should take 44.47 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:33:53. ... 1028096 iterations done in 7.454*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:07:13. 1030144 iterations done in 7.470*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:11:43. 1032192 iterations done in 7.485*10^5 seconds. Should take 44.54 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:12:48.  A long-term power outage stopped this computation! # I so dearly want to see more digits of the MRB constant: Please, anyone, please help here!! Answer Posted 3 years ago Would anyone let me know how this comes out on your computer? Here is a link to my Nov 16, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 18, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 19, 2018 update of calculating 4 million digits of MRB: HERE, Here is a link to my Nov 20, 2018 update of calculating 4 million digits of MRB: HERE Here is a link to my Nov 21, 2018 update of calculating 4 million digits of MRB: HERE Here is a link to my Nov 22, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 24, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 27, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Dec 05, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Dec 10, 2018 update of calculating 4 million digits of MRB: HERE. ## Last update of 2018 5:37:20 pm EST | Monday, December 31, 2018 (49.04 days from start time), 75.2315 percent completed . 3,024,300 digits computed.3993600 iterations done in 4.23810^6 seconds. Should take 65.18 days or 5.63110^6s, finish Wed 16 Jan 2019 20:57:47. (16.64 days from now). ## Probably the last update 12:47:20 am EST | Monday, January 14, 2019 (62.3495 days from start time), 95.679 percent completed . 3,846,295 digits computed. 5079040 iterations done in 5.38710^6 seconds. Should take 65.15 days or 5.62910^6s, finish Wed 16 Jan 2019 20:13:07. (2.81 days from now). Answer Posted 3 years ago  Finished on Wed 16 Jan 2019 19:55:20, I computed over 4 million digits of the MRB constant!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!..... It took 65.13 days with a processor time of 25.17 days.On a 3.7 GH overclocked up to 4.7 GH on all cores Intel 6 core computer with 3000 MHz RAM. See attached notebook.Watch my reaction here. Attachments: Answer Posted 3 years ago # Attempts at a 5,000,000 digit calculation ## First effort: Tue 22 May 2018 I started a 5,000,000 digits calculation on my 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB DDR4 ram running at 2400 MHz in Windows 10 Pro using a version of my Burns-Crandall hybrid code supercharged with 4 iterations of my 4th order convergence subroutine. See April 2018 5 million digits try.nb for exact code and results of the incomplete computation. Here are some of the results: Start time is Tue 22 May 2018 01:02:37. Iterations required: 6632998 Will give 3239 time estimates, each more accurate than the previous. Will stop at 6633472 iterations to ensure precision of around 5024999 decimal places. 0 iterations done in 3301. seconds. Should take 2.534*10^9 days or 2.189*10^14s, finish Mon 11 Nov 6939709 17:32:23. 2048 iterations done in 6503. seconds. Should take 243.8 days or 2.106*10^7s, finish Sun 20 Jan 2019 19:11:08. 4096 iterations done in 9721. seconds. Should take 182.2 days or 1.574*10^7s, finish Tue 20 Nov 2018 05:57:47. 6144 iterations done in 1.295*10^4 seconds. Should take 161.8 days or 1.398*10^7s, finish Tue 30 Oct 2018 21:15:01. 8192 iterations done in 1.623*10^4 seconds. Should take 152.1 days or 1.314*10^7s, finish Sun 21 Oct 2018 03:44:45. 10240 iterations done in 1.964*10^4 seconds. Should take 147.3 days or 1.272*10^7s, finish Tue 16 Oct 2018 07:34:30. 12288 iterations done in 2.312*10^4 seconds. Should take 144.4 days or 1.248*10^7s, finish Sat 13 Oct 2018 11:43:37. 14336 iterations done in 2.667*10^4 seconds. Should take 142.8 days or 1.234*10^7s, finish Thu 11 Oct 2018 20:49:04. 16384 iterations done in 2.998*10^4 seconds. Should take 140.5 days or 1.214*10^7s, finish Tue 9 Oct 2018 12:13:43. 18432 iterations done in 3.326*10^4 seconds. Should take 138.5 days or 1.197*10^7s, finish Sun 7 Oct 2018 13:48:39.  I felt this was going too slow so I got more computing power!!! ## Second effort: Sun 20 Jan 2019 21:06:58 I've made a lot better progress with the following!!! 6 kernels, 3.7 GH overclocked up to 4.7 GH, Intel 6core 3000MH RAM, w/ 8 kernels of 3.6 GH 4 core, 2400MH RAM (with optimized use of kernel priority) Needs["SubKernelsLocalKernels"] Block[{$mathkernel = $mathkernel <> " -threadpriority=2"}, LaunchKernels[]](*optimized use of kernel priority for master computer being the fastest one*)  Out[3]= {"KernelObject"[1, "burns"], "KernelObject"[2, "burns"], "KernelObject"[3, "burns"], "KernelObject"[4, "burns"], "KernelObject"[5, "burns"], "KernelObject"[6, "burns"], "KernelObject"[7, "burns"], "KernelObject"[8, "burns"], "KernelObject"[9, "local"], "KernelObject"[10, "local"], "KernelObject"[11, "local"], "KernelObject"[12, "local"], "KernelObject"[13, "local"], "KernelObject"[14, "local"]} Print["Start time is ", ds = DateString[], "."]; prec = 5000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/24768]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4096, pc = Min[3 pc, pr/4096]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/4096]**)x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/1024]*)x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/256]*)x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/64]**)x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/16]**)x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/ ll],pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s. Finish ", DatePlus[ds, ti], "."]; Print[Text[ Style[{IntegerPart[kc/(end*chunksize)*100], "% done."}, FontSize -> Large]]], {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Actual time was ", st]; (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \ output*); Print["Enter MRBtest2 to print ", Floor[Precision[ MRBtest2]], " digits"]; Print["If you saved m3M, the difference \ between this and 4,000,000 known digits is ", N[MRBtest2 - m4M, 10]]   Start time is Sun 20 Jan 2019 21:06:58. Iterations required: 6632998 Will give 3239 time estimates, each more accurate than the previous. Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places. 0 iterations done in 1893. seconds. Should take 1.454*10^9 days or 1.256*10^14s. Finish Sun 16 Apr 3981600 03:48:25. {0,% done.} 2048 iterations done in 3801. seconds. Should take 142.5 days or 1.231*10^7s. Finish Wed 12 Jun 2019 08:24:54. {0,% done.} 4096 iterations done in 5774. seconds. Should take 108.2 days or 9.351*10^6s. Finish Thu 9 May 2019 02:36:43. {0,% done.} 6144 iterations done in 7744. seconds. Should take 96.76 days or 8.360*10^6s. Finish Sat 27 Apr 2019 15:27:12. {0,% done.} 8192 iterations done in 9655. seconds. Should take 90.48 days or 7.818*10^6s. Finish Sun 21 Apr 2019 08:42:56. {0,% done.} 10240 iterations done in 1.160*10^4 seconds. Should take 86.95 days or 7.512*10^6s. Finish Wed 17 Apr 2019 19:49:38. {0,% done.} 12288 iterations done in 1.351*10^4 seconds. Should take 84.43 days or 7.295*10^6s. Finish Mon 15 Apr 2019 07:29:22. {0,% done.} 14336 iterations done in 1.544*10^4 seconds. Should take 82.67 days or 7.143*10^6s. Finish Sat 13 Apr 2019 13:14:41. {0,% done.} 16384 iterations done in 1.737*10^4 seconds. Should take 81.39 days or 7.032*10^6s. Finish Fri 12 Apr 2019 06:34:15. {0,% done.} 18432 iterations done in 1.931*10^4 seconds. Should take 80.42 days or 6.948*10^6s. Finish Thu 11 Apr 2019 07:06:55. {0,% done.}  ![enter image description here][1] See 5 million 01 2019.nb for full progress. The cluster is processing 1.024 5,000,000 digit iterations of n^(1/n) per second. It is completing 1% every 18 hours, 3 minutes and 36 seconds. Well, the power went out here in INDY, again. My 6 year old battery backup is becoming worthless on handling 2 computers for very long. I will try to build some better household infrastructure. Plus, there is still the possibility of breaking my program up so it does smaller portions of the computation at a time. But, I haven't figured how to do that yet! I will let you know when I'm ready to try again. It took over 8 tries for 4 million digits, so I'm not heartbroken that this second try of 5 million digit didn't work out. ## Third effort: 5/3/2019 Using the MRB constant supercomputer described in the next post, we now have much better progress, as shown in 5 million 05 2019.nb:  Start time is Sun 12 May 2019 10:23:26. Iterations required: 6632998 Will give 3239 time estimates, each more accurate than the previous. Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places. 0 iterations done in 1482. seconds. Should take 1.138*10^9 days or 9.829*10^13s. Finish Thu 23 Jan 3116775 18:57:34. {0,% done.} 2048 iterations done in 2986. seconds. Should take 111.9 days or 9.672*10^6s. Finish Sun 1 Sep 2019 08:57:12. {0,% done.} 4096 iterations done in 4503. seconds. Should take 84.39 days or 7.292*10^6s. Finish Sun 4 Aug 2019 19:49:39. {0,% done.} 6144 iterations done in 6036. seconds. Should take 75.42 days or 6.516*10^6s. Finish Fri 26 Jul 2019 20:21:33. {0,% done.} 8192 iterations done in 7562. seconds. Should take 70.87 days or 6.123*10^6s. Finish Mon 22 Jul 2019 07:13:15. {0,% done.} 10240 iterations done in 9106. seconds. Should take 68.27 days or 5.898*10^6s. Finish Fri 19 Jul 2019 16:47:37. {0,% done.} 12288 iterations done in 1.064*10^4 seconds. Should take 66.46 days or 5.743*10^6s. Finish Wed 17 Jul 2019 21:32:38. {0,% done.} 14336 iterations done in 1.218*10^4 seconds. Should take 65.24 days or 5.636*10^6s. Finish Tue 16 Jul 2019 16:03:55. {0,% done.} 16384 iterations done in 1.372*10^4 seconds. Should take 64.31 days or 5.556*10^6s. Finish Mon 15 Jul 2019 17:46:42. {0,% done.} 18432 iterations done in 1.527*10^4 seconds. Should take 63.62 days or 5.496*10^6s. Finish Mon 15 Jul 2019 01:09:08. {0,% done.}  Wish me luck! Here is the latest output: 131072 iterations done in 1.026*10^5 seconds. Should take 60.11 days or 5.193*10^6s. Finish Thu 11 Jul 2019 13:00:35. {1,% done.} 133120 iterations done in 1.042*10^5 seconds. Should take 60.10 days or 5.193*10^6s. Finish Thu 11 Jul 2019 12:53:13. {2,% done.} 135168 iterations done in 1.058*10^5 seconds. Should take 60.09 days or 5.192*10^6s. Finish Thu 11 Jul 2019 12:35:29. {2,% done.} 137216 iterations done in 1.074*10^5 seconds. Should take 60.09 days or 5.192*10^6s. Finish Thu 11 Jul 2019 12:29:39. {2,% done.} 139264 iterations done in 1.090*10^5 seconds. Should take 60.08 days or 5.191*10^6s. Finish Thu 11 Jul 2019 12:15:25. {2,% done.}.  Followed by 196608 iterations done in 1.543*10^5 seconds. Should take 60.27 days or 5.207*10^6s. Finish Thu 11 Jul 2019 16:48:37. {2,% done.} 198656 iterations done in 1.559*10^5 seconds. Should take 60.26 days or 5.207*10^6s. Finish Thu 11 Jul 2019 16:40:38. {2,% done.} 200704 iterations done in 1.575*10^5 seconds. Should take 60.25 days or 5.206*10^6s. Finish Thu 11 Jul 2019 16:26:21. {3,% done.}  Followed by 264192 iterations done in 2.075*10^5 seconds. Should take 60.30 days or 5.210*10^6s. Finish Thu 11 Jul 2019 17:34:10. {3,% done.} 266240 iterations done in 2.091*10^5 seconds. Should take 60.29 days or 5.209*10^6s. Finish Thu 11 Jul 2019 17:24:24. {4,% done.}  Well, for an unknown reason Mathematica 11.3 asked whether I wanted to close the program and had not displayed any new information since my last checking it 18 hours ago. ## Fourth effort: Thu 16 May 2019 15:39:40 I restarted the 5 million digit computation. For an unknown reason it is a little slower this time, but what's important is that it gets completed! See attached B 5 million 05 2019.nb. 0 iterations done in 1520. seconds. Should take 1.167*10^9 days or 1.008*10^14s. Finish Sun 13 Dec 3197801 13:09:30. {0,% done.} 2048 iterations done in 3103. seconds. Should take 116.3 days or 1.005*10^7s. Finish Mon 9 Sep 2019 23:32:26. {0,% done.} 4096 iterations done in 4697. seconds. Should take 88.04 days or 7.607*10^6s. Finish Mon 12 Aug 2019 16:42:17. {0,% done.} 6144 iterations done in 6298. seconds. Should take 78.69 days or 6.799*10^6s. Finish Sat 3 Aug 2019 08:14:25. {0,% done.} 8192 iterations done in 7899. seconds. Should take 74.02 days or 6.396*10^6s. Finish Mon 29 Jul 2019 16:13:37. {0,% done.} 10240 iterations done in 9465. seconds. Should take 70.96 days or 6.131*10^6s. Finish Fri 26 Jul 2019 14:47:42. {0,% done.} 12288 iterations done in 1.102*10^4 seconds. Should take 68.87 days or 5.950*10^6s. Finish Wed 24 Jul 2019 12:33:43. {0,% done.} 14336 iterations done in 1.260*10^4 seconds. Should take 67.48 days or 5.830*10^6s. Finish Tue 23 Jul 2019 03:13:52. {0,% done.} 16384 iterations done in 1.418*10^4 seconds. Should take 66.44 days or 5.740*10^6s. Finish Mon 22 Jul 2019 02:08:54. {0,% done.}  6:56:20 pm EDT | Sunday, May 19, 2019: {4,% done.} 331776 iterations done in 2.710*10^5 seconds. Should take 62.71 days or 5.418*10^6s. Finish Thu 18 Jul 2019 08:46:13. {5,% done.}  # ... It is completing 1% every 15 hours 16 minutes 40.08 seconds. Should reach 99% at 4:56:20 am EDT | Friday, July 19, 2019. 4:39:40 am EDT | Friday, July 19, 2019 {98,% done.} 6567936 iterations done in 5.490*10^6 seconds. Should take 64.17 days or 5.544*10^6s. Finish Fri 19 Jul 2019 19:43:06. {99,% done.}  It is completing 1% every 15 hours 0 minutes 0 seconds. Should reach 100% at 7:39:40 pm EDT | Friday, July 19, 2019. {99,% done.} Finished on Fri 19 Jul 2019 18:49:02. Processor time was 3.46012*10^6 s. Actual time was 5.5409619988176*10^6 Enter MRBtest2 to print 5024991 digits If you saved m3M, the difference between this and 4,000,000 known digits is 0.*10^-4000001  For this 5 million calculation of MRB using the 3 node MRB supercomputer processor time was 40 days and actual time was 64 days. That is faster than the 4 million digit computation using just one node. See "Final results fo...nb" for full input, results and 5 million and a little more digits. Attachments: Answer Posted 3 years ago As mentioned a few times above Richard Crandall made the following observations about the MRB constant: His last comment is that we might find some algorithm advantages by focusing on the fixed argument of 0 for the eta derivatives. He gives Chapter 3 as a possible source to find the algorithm advantages. (Here is another link to his paper: http://marvinrayburns.com/UniversalTOC25.pdf .) Here is what he was looking for. c[0] = 0; c[1] = Log[2]; Table[ c[n] = -2*Derivative[n - 1][Zeta][0], {n, 2, 22}]; l = CoefficientList[Normal[Series[Exp[(-x)*E^x], {x, 0, 21}]], x]; N[-Sum[ l[[n + 1]]*((-1)^ n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), {x, 1, n - 1}] + c[1]^n + c[0]) + 1/2 c[n + 1]), {n, 1, 17}]]  Mathematica still has trouble with higher zeta derivatives of 0, however. I'm going to look for a procedure for computing them better. ##  I computed the zeta derivatives of 0 by  zeta0[p_] := (-1)^p Sum[StieltjesGamma[p + k]/k!, {k, 0, Infinity}] - p!  and got the same results Mathematica got for the higher zeta derivatives of 0. I also checked the CoefficientList of CoefficientList[Normal[Series[Exp[(-x)*E^x], {x, 0, 21}]]  by the following, and haven't found where Mathematica is having trouble! c[0] = 0; c[1] = Log[2]; Table[c[n] = -2*Derivative[n - 1][Zeta][0], {n, 2, 18}]; N[-Sum[(Sum[(-1)^d*d^(n - d)*Binomial[n, d], {d, 1, n}]* ((-1)^ n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), {x, 1, n - 1}] + c[1]^n + c[0]) + (1/2)* c[n + 1]))/n!, {n, 1, 17}]]  I even checked the binomials by their formula. Also the StieltjesGamma and Derivative[n ][Zeta][0]] results appear smooth for discrete operations:  Table[N[Derivative[n ][Zeta][0]], {n, 10, 25}]  and  N[Table[StieltjesGamma[x], {x, 1, 30}]]  . ##  I found the problem as to why Mathematica doesn't increase its accuracy in the above formula after 17 iterations: Mathematica will give a numeric solution to many zeta derivatives of 0, only to machine precision! For machine precision:  Table[N[Derivative[n ][Zeta][0]], {n, 1, 30}]  gives the machine sized numeric to many derivatives:  {-0.918939, -2.00636, -6.00471, -23.9971, -120., -720.001, \ -5040., -40320., -362880., -3.6288*10^6, -3.99168*10^7, \ -4.79002*10^8, -6.22702*10^9, -8.71783*10^10, -1.30767*10^12, \ -2.09228*10^13, -3.55687*10^14, -6.40237*10^15, -1.21645*10^17, \ -2.4329*10^18, -5.10909*10^19, -1.124*10^21, -2.5852*10^22, \ -6.20448*10^23, -1.55112*10^25, -4.03291*10^26, -1.08889*10^28, \ -3.04888*10^29, -8.84176*10^30, -2.65253*10^32}.  Then  Table[N[Derivative[n][Zeta][0], 10], {n, 1, 30}]  gives the high precision numeric for only the first 3 derivatives: {-0.9189385332046727417803297364056176398610., \ -2.006356455908584851210100026729960438210., -6.004711166862254447810., Derivative[4][Zeta][0], Derivative[5][Zeta][0], Derivative[6][Zeta][0], Derivative[7][Zeta][0], Derivative[8][Zeta][0], Derivative[9][Zeta][0], Derivative[10][Zeta][0], Derivative[11][Zeta][0], Derivative[12][Zeta][0], Derivative[13][Zeta][0], Derivative[14][Zeta][0], Derivative[15][Zeta][0], Derivative[16][Zeta][0], Derivative[17][Zeta][0], Derivative[18][Zeta][0], Derivative[19][Zeta][0], Derivative[20][Zeta][0], Derivative[21][Zeta][0], Derivative[22][Zeta][0], Derivative[23][Zeta][0], Derivative[24][Zeta][0], Derivative[25][Zeta][0], Derivative[26][Zeta][0], Derivative[27][Zeta][0], Derivative[28][Zeta][0], Derivative[29][Zeta][0], Derivative[30][Zeta][0]}.  With some confidence I can say I fixed it!!! I forced Mathematica to give up the needed digits of the zeta derivatives. My new program does not really compete with the previously mentioned record-breakers. But it is a fairly efficient use of Crandall's formula (44). First it calculates many digits on MRB the old fashion way to use as a check. So here is my new program: m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 120]; Block[{$MaxExtraPrecision = 1000}, s = 100(*number of terms*);
c[1] = Log[2];
c[n_] := N[1 - 2*Derivative[n - 1][Zeta][0], Floor[3/2 s]] - 1;
mtest = (-Sum[(Sum[(-1)^d*d^(n - d)*Binomial[n, d], {d, 1,
n}]*((-1)^
n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), {x,
1, n - 1}] + c[1]^n) + (1/2)*c[n + 1]))/n!, {n, 1,
s}])]; Print[s, " terms give ", mtest, ", and the error is ",
m - mtest]


100 terms give 0.18785964486341229249700337222, and the error is -2.40134517224848543816*10^-9

Changing s to 200 shows all correct digits:

200 terms give 0.187859642465, and the error is -3.*10^-12

Posted 2 years ago

## 3/23/2019

Well, my mania struck again!!!!! I bought another computer that I can't afford.

3.7 GH overclocked up to 4.7 GHz on all Intel 6 cores at 3000 MHz RAM

and 4 cores of 3.6 GHz at 2400 MHz RAM,

with optimized use of kernel priority in my programs, I should be able to compute up to 10 million digits! And, according to results from a well known cloud I tried out, my cluster should be faster than a Intel Xeon Platinum 8151 @ 3.4 GHz with 24 cores!! (in using my programs for many computations of MRB)

Here are the details of my new computer: Processor: Intel Core i9-9900K (5.0 GHz Turbo) (16-Thread) (8-Core) 3.6 GHz. CPU Boost: Stage 2: Overclock CPU - Up to 5.1GHz on All CPU Cores at 3200 Mhz RAM Extreme Cooling: H20: Stage 2: Corsair H115i PRO - 280mm Liquid CPU Cooler (Fully Sealed + No Maintenance)

Total: $2,695.00. That is less than 1/10th the price of any single computer that can do the same as the new cluster!!!!!! Using the 3 node MRB constant super computer, I got the following red column for seconds on computing the MRB constant. Documented in the attached ":3 fastest computers together 3.nb." Pay special attention to the new record 45.5 hour million digit computation!!!!!!! Attachments: Answer Posted 2 years ago ## 4/22/2019 Let $$M=\sum _{n=1}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right).$$ Then using what I learned about the absolute convergence of$\sum _{n=1}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}$from https://math.stackexchange.com/questions/1673886/is-there-a-more-rigorous-way-to-show-these-two-sums-are-exactly-equal, combined with an identity from Richard Crandall: , Also using what Mathematica says: $$\sum _{n=1}^1 \frac{\underset{m\to 1}{\text{lim}} \eta ^n(m)}{n!}=\gamma (2 \log )-\frac{2 \log ^2}{2},$$ I figured out that $$\sum _{n=2}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-\frac{\log (n)}{n}-1\right).$$ So I made the following major breakthrough in computing MRB from Candall's first eta formula. See attached 100 k eta 4 22 2019. Also shown below. The time grows 10,000 times slower than the previous method! I broke a new record, 100,000 digits: Processor and total time were 806.5 and 2606.7281972 s respectively.. See attached 2nd 100 k eta 4 22 2019. Here is the work from 100,000 digits. Print["Start time is ", ds = DateString[], "."]; prec = 100000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4, pc = Min[3 pc, pr/4]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/ ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(** N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 32]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Enter MRBtest2 to print ", Floor[Precision[MRBtest2]], " digits"]; (Start time is )^2Tue 23 Apr 2019 06:49:31. Iterations required: 132026 Will give 65 time estimates, each more accurate than the previous. Will stop at 133120 iterations to ensure precsion of around 100020 decimal places. Denominator computed in 17.2324041s.  ## ... 129024 iterations done in 1011. seconds. Should take 0.01203 days or 1040.s, finish Mon 22 Apr 2019 12:59:16. 131072 iterations done in 1026. seconds. Should take 0.01202 days or 1038.s, finish Mon 22 Apr 2019 12:59:15. Finished on Mon 22 Apr 2019 12:59:03. Processor time was 786.797 s.   Print["Start time is " "Start time is ", ds = DateString[], "."]; prec = 100000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{lg, a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*= 4*number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.0002 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = pr/2^6; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; lg = Log[ll]/(ll); x = N[E^(lg), iprec]; pc = iprec; While[pc < pr, pc = Min[4 pc, pr]; x = SetPrecision[x, pc]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pc] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, 2 pc] ll (ll - 1)/(3 ll t2 + t^3 z))]; x - lg, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 16]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-10)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st - stt, 4], " seconds.", " Should take ", N[ti, 4], " days or ", ti*3600*24, "s, finish ", DatePlus[ds, ti], "."], Print["Denominator computed in ", stt = st, "s."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBeta2toinf = expM[prec];]; Print["Finished on ", DateString[], ". Processor and total time were ", t2[[1]], " and ", st, " s respectively."]; Start time is Tue 23 Apr 2019 06:49:31. Iterations required: 132026 Will give 65 time estimates, each more accurate than the previous. Will stop at 133120 iterations to ensure precision of around 100020 decimal places. Denominator computed in 17.2324041s.  ## ... 131072 iterations done in 2589. seconds. Should take 0.03039 days or 2625.7011182s, finish Tue 23 Apr 2019 07:33:16. Finished on Tue 23 Apr 2019 07:32:58. Processor and total time were 806.5 and 2606.7281972 s respectively.   MRBeta1 = EulerGamma Log[2] - 1/2 Log[2]^2 EulerGamma Log[2] - Log[2]^2/2   N[MRBeta2toinf + MRBeta1 - MRB, 10] 1.307089967*10^-99742  Attachments: Answer Posted 2 years ago  See distribution method.nb for how I got the following distribution tablesHere is the distribution of digits within the first 5,000,000 decimal places (.187859,,,), "4" shows up a lot more than other digits, followed by "0," "8"and "6." Here is a similar distribution over the first 4,000,000: 3,000,000 digits share a similar distribution:Over the first 2 and 1 million digits "4" was not so well represented. So, the heavy representation of "4" is shown to be a growing phenomenon from 2 million to 5 million digits. However, "1,2,and 5" still made a very poor showing: Attachments: Answer Posted 2 years ago ## 8/24/2019 It's time for more digits! Using the 3 node MRB constant supercomputer, I started the 6 million digit computation of the MRB constant. For some unknown reason, the kernel closed at 9:09:35 pm EDT | Saturday, August 31, 2019. I can't stand not trying to make progress!!!! so I started the 6 million digits run again. More info coming soon! Start time is Mon 16 Sep 2019 15:35:29.  Answer Posted 2 years ago There seems to be a major problem with calculating 6,000,000 digits via my program. The problem is reproducible -- the kernel went offline at the same time in both tries. I'm not sure about my next step!!!!!!! ## UPDATE I'm experimenting with virtual RAM. I created a 64 to 128 GB virtual RAM page and started the computation again on Mon 7 Oct 2019 20:50:12. Here are some random moments where I recorded the memory usage: 5:36:52 pm EDT | Saturday, October 26, 2019: {15,% done.} 1273856 iter. done in 1.630*10^6 s. Ave. 0.78157iter./s. Should take 117.87 days or 1.018*10^7s. Finish Sun 2 Feb 2020 17:45:26. {16,% done.}  ... 7:10:12 pm CST | Tuesday, November 26, 2019: {42,% done.} 3424256 iter. done in 4.314*10^6 s. Ave. 0.79375iter./s. Should take 116.06 days or 1.003*10^7s. Finish Fri 31 Jan 2020 22:20:28. {43,% done.}  More to come. Attachments: Answer Posted 2 years ago  Well, my internet went out!!!!! To get it working, I had to reset my router. This killed the computation at 44% at 8:17:42 am EST | Thursday, November 28, 2019. I attached the notebook showing all of my progress. Attachments: Answer Posted 2 years ago ## Breaking News At https://math.stackexchange.com/questions/2564705/what-are-some-working-models-that-are-a-fit-the-formula-for-the-mrb-constant/3505694#3505694, an internet scholar going by the user name Dark Malthorp found the following formulas for CMRB. Some may be useful for breaking new records. I'm particularly am fond of CMRB=. It seems to be true, as shown next.  Quiet[ Timing[mi = NIntegrate[ Im[(1 + I t)^(1/(1 + I t))]/Sinh[Pi t], {t, 0, Infinity}, WorkingPrecision -> 1000, Method -> "Trapezoidal"]][[1]]]  gives 5.29688 seconds.  Timing[ ms = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]][[1]]  gives 0.234375 seconds.  mi - ms  gives -3.*10^-998. Answer Posted 1 year ago  On 2/24/2020 at 4:35 pm, I started a 10,000 digit calculation of the MRB constant using the integralHere is the code:First, compute 10,000 digits using Mathematica's "AlternatingSigns" option. ms = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 10000]; Then compute the integral. Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 5000, Method -> "Trapezoidal", PrecisionGoal -> 10000, MaxRecursion -> 50]] It is still working now on 2/26/2020 at 6:05 pm.I messed up, but I'll let the computation complete anyway. (My integral's result will only have around 5000 digits of precision -- so I should expect it to only be that accurate when I compare it to the sum.) But, this computation will give the approximate time required for a 10,000 digit calculation with that MaxRecursion (which might be way more than enough!)It is still running at 7:52 am on 2/27/2020. The computer has been running at right around 12 GB of RAM committed and 9 GB of RAM in use, since early in the computation.I started a second calculation on a similar computer. This one will be faster and give us a full 10,000 digits. But I reduced the MaxRecursion somewhat significantly. We'll see if all 10 k digits are right...code Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 10000, Method -> "Trapezoidal", PrecisionGoal -> 10000, MaxRecursion -> 35]] That lower threshold for MaxRecursion worked just fine!!!!!!!!!!!!!!! It took only 7497.63 seconds (roughly 2 hours) to calculate 10,000 accurate digits of the MRB constant from the integral.2/27/2020 at 9:15 PM:I just now started15,000 and a 20,000 digit computations of the integral form of the MRB constant. The 15,000 digit calculation of the MRB constant through the integral, finished in 15,581s (4.328 hours) and was correct to all 15,000 digits!!!!!!!I also calculated 20,000 correct digits in 51,632s (14.34 hr) using the integral code Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 20000, Method -> "Trapezoidal", PrecisionGoal -> 20000, MaxRecursion -> 30]] Furthermore, I calculated 25,000 correct digits in 77,212.9s (21.45 hr) using the integral code Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 25000, Method -> "Trapezoidal", PrecisionGoal -> 25000, MaxRecursion -> 30]] I think that does wonders to confirm the true approximated value of the constant. As calculated by both and to at least 25,000 decimals, the true value of the MRB constant is ms=mi≈ [Attached "MRB to 25k confirmed digits.txt"].Computation and check of 25k digit integral calculation found in "comp of 25k confirmed digits.nb".As 0f March 2, 2020, I'm working on timed calculations of 30k,50k and 100k digits of the integral. I finished a 30,000 accurate digit computation of the MRB constant via an integral in 78 hours. See "comp of 25k and 30k confirmed digits b.nb" for the digits and program.Also, I finished a 50,000 accurate digit computation of the MRB constant via an integral in 6.48039 days. See "up to 50k digits of a MRB integral.nb" for the digits and program. Attachments: Answer Posted 1 year ago  It's just too beautiful not to point out the symmetry between the sum and integral formulas we are using to calculate the same digits. Answer Posted 1 year ago ## 4th Try at 6,000,000 (6 million) Digits I thought about waiting to see if I was successful to 30% completion before posting about my new effort, but being isolated, I kinda need someone to talk to, so here's the code and results so far: Start time is Wed 18 Mar 2020 21:14:14.  ... 796672 iter. done in 8.647*10^5 s. Ave. 0.92134iter./s. Should take 99.990 days or 8.639*10^6s. Finish Fri 26 Jun 2020 20:59:28. {10,% done.} ...  Answer Posted 1 year ago ## 5th Try at 6,000,000 (6 million) Digits The internet connection between my computers went out again! I guess I'll have to use just one computer and calculate my 6,000,000 digits the slow way. Well, at least this MRB records posting has reached a milestone of over 120,000 views on 3.31.2020, around 4:00 am. So I restarted the computation on a single computer. I'm using basically the same code as before.  Here are the most recent results at 9:12:15 pm EDT | Friday, May 1, 2020: 1409024 iter.done in 2.71910^6 s.Ave.0.51820 iter./s.It should take 177.78 days or 1.53610^7 s. Finish Fri 25 Sep 2020. 04 : 37 : 56. N[1409024/ 7960576 *100] "percent done"  17.7 "percent done" Answer Posted 1 year ago  In 38 1/2 days, I computed 100,000 digits of the MRB constant from the Here is the code: Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 100000, Method -> "Trapezoidal", PrecisionGoal -> 100000, MaxRecursion -> 30]] I attached the notebook with the results. Attachments: Answer Posted 1 year ago ## A nontrivial close approximation of m=The MRB constant = =. The initial pair of terms in is A= -1. And the initial pair of terms in is B=. |m+A-B-|<1.8*10^-11.  m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 30, Method -> "AlternatingSigns"]; A = Sqrt[2] - 1; B = (EulerGamma Log[2] - 1/2 Log[2]^2); m + A - B - 329/744  gives 1.746238008901875046*10^-11.  I wonder what approximations we can come up with using more terms of the MRB constant summations and whether the approximations can be used to check the digits of the large MRB constant calculations. Going up to one more pair of terms from the two MRB constant series, I found the following: m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 30, Method -> "AlternatingSigns"]; A = Sqrt[2] - 1; B = (EulerGamma Log[2] - 1/2 Log[2]^2); C1 = -3^(1/3) + 4^(1/4); D1 = (-1)^n Derivative[n][DirichletEta][n]/n! /. n -> 2; (m - A + B - C1 + D1) + 7/110  gives -4.3311064622052860297078*10^-7.  Going up even one more pair of terms from the two MRB constant series, I found the following in a similar pattern, but the precision is reducing rather than increasing as I had hoped.  m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 30, Method -> "AlternatingSigns"]; A = Sqrt[2] - 1; B = (EulerGamma Log[2] - 1/2 Log[2]^2); C1 = -3^(1/3) + 4^(1/4); C2 = -5^(1/5) + 6^(1/6); D1 = (-1)^n Derivative[n][DirichletEta][n]/n! /. n -> 2; D2 = (-1)^n Derivative[n][DirichletEta][n]/n! /. n -> 3; (m + A - B + C1 - D1 - C2 - D2) - 9/19  gives  -9.02675732851111938451197*10^-6.  Answer Posted 1 year ago In the same vein of a non-trivial approximation: The MRB constant =m. m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 30, Method -> "AlternatingSigns"];  We know from previous posts, To find how fast this integral converges to m, I entered lsmall = Table[ m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x}, WorkingPrecision -> 40], {x, 1, 20}]; N[Ratios[1/lsmall], 15]  followed by the slower lbig = Table[ m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x}, WorkingPrecision -> 240], {x, 101, 120}]; N[Ratios[1/lbig], 15]  and ended up with values that converged to 23.2958716448535.  Using those ratios, it looks like Since that is a form of 0/0, we can use L'Hospital's Rule and see that it is true: Limit[(Csch[\[Pi] t] Im[(1 + I t)^(1/( 1 + I t))])/(Csch[\[Pi] (t + 1)] Im[(1 + I (t + 1))^(1/( 1 + I ( t + 1)))]), t -> Infinity]  gives Now for the part that is similar to the approximations mentioned in the immediate, previous post. You may know that N[20/(E^Pi - Pi), 9]  gives 1.00004500.  While N[2 - 100/(E^Pi/m - E^Pi), 8]  gives 1.0004005.  Furthermore, N[2 - 100/(E^Pi/m - E^Pi), 12]/N[20/(E^Pi - Pi), 12]  gives 1.00035544632.  While N[3 - 100/(E^Pi/m - E^Pi), 12] - N[20/(E^Pi - Pi), 12]  gives 1.00035546231.  Holy double, double vision Batman! There is a way to make the approximations of 20/(E^Pi - Pi) vs 2 - 100/(E^Pi/x - E^Pi), where x is a relation to m, equal to 11 digits, instead of just similar to 9, using the parking constant. E^Pi is involved in a term again! (The term is a Cosmological constant, of sorts.) (*parking constant,c*) c = NIntegrate[ E^(-2*(EulerGamma + Gamma[0, t] + Log[t])), {t, 0, Infinity}, WorkingPrecision -> 50, MaxRecursion -> 20];  Let ma be the MRB constant with that term: ma = m + (2/3 - E^Pi)/(1/3 - c)/10^6;  Calculating more digits of 20/(E^Pi - Pi): N[20/(E^Pi - Pi), 12]  gives 1.00004500307.  Calculating the new sum with ma instead of m: N[2 - 100/(E^Pi/ma - E^Pi), 12]  gives 1.00004500308.  What about the second of the similar-looking approximated sums, N[2 - 100/(E^Pi/x - E^Pi), 15]/N[20/(E^Pi - Pi), 15] vs.N[3 - 100/(E^Pi/x - E^Pi), 16] - N[20/(E^Pi - Pi), 16]? So we have the new x, ma. Then N[2 - 100/(E^Pi/ma - E^Pi), 15]/N[20/(E^Pi - Pi), 15]  gives 1.00000000001744.  While N[3 - 100/(E^Pi/ma - E^Pi), 16] - N[20/(E^Pi - Pi), 16]  gives the exactly the same value of 1.000000000017440.  ## Holy corrected vision Batman! Answer Posted 1 year ago  m=the MRB constant. We looked at how n^m-m is similar to E^Pi-Pi (a near integer). One might think this is off the subject of breaking computational records of the MRB constant, but it also could help show whether there exists a closed-form for computing and checking the digits of m from n^m-m=a near integer and n is an integer.So, I decided to make an extremely deep search of the n^m-m=a near integer, and n is an integer field. Here are the pearls I gleaned: In[35]:= m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100, Method -> "AlternatingSigns"]; In[63]:= 225897077238546^m - m Out[63]= 496.99999999999999975304752932252481772179797865 In[62]:= 1668628852566227424415^m - m Out[62]= 9700.9999999999999999994613109586919797992822178 In[61]:= 605975224495422946908^m - m Out[61]= 8019.9999999999999999989515156294756517433387956 In[60]:= 3096774194444417292742^m - m Out[60]= 10896.0000000000000000000000096284579090392932063 In[56]:= 69554400815329506140847^m - m Out[56]= 19549.9999999999999999999999991932013520540825206 In[68]:= 470143509230719799597513239^m - m Out[68]= 102479.000000000000000000000000002312496475978584 In[70]:= 902912955019451288364714851^m - m Out[70]= 115844.999999999999999999999999998248770510754951 In[73]:= 2275854518412286318764672497^m - m Out[73]= 137817.000000000000000000000000000064276966095482 In[146]:= 2610692005347922107262552615512^m - m Out[146]= 517703.00000000000000000000000000000013473353420 In[120]:= 9917209087670224712258555601844^m - m Out[120]= 665228.00000000000000000000000000000011062183643 In[149]:= 19891475641447607923182836942486^m - m Out[149]= 758152.00000000000000000000000000000001559954712 In[152]:= 34600848595471336691446124576274^m - m Out[152]= 841243.00000000000000000000000000000000146089062 In[157]:= 543136599664447978486581955093879^m - m Out[157]= 1411134.0000000000000000000000000000000035813431 In[159]:= 748013345032523806560071259883046^m - m Out[159]= 1498583.0000000000000000000000000000000031130944 In[162]:= 509030286753987571453322644036990^m - m Out[162]= 1394045.9999999999999999999999999999999946679646 In[48]:= 952521560422188137227682543146686124^m - m Out[48]=5740880.999999999999999999999999999999999890905129816474332198321490136628009367504752851478633240 In[26]:= 50355477632979244604729935214202210251^m - m Out[26]=12097427.00000000000000000000000000000000000000293025439870097812782596113788024271834721860892874 In[27]:= 204559420776329588951078132857792732385^m - m Out[27]=15741888.99999999999999999999999999999999999999988648448116819373537316944519114421631607853700001 In[46]:= 4074896822379126533656833098328699139141^m - m Out[46]= 27614828.00000000000000000000000000000000000000001080626974885195966380280626150522220789167201350 In[8]:= 100148763332806310775465033613250050958363^m - m Out[8]= 50392582.999999999999999999999999999999999999999998598093272973955371081598246 In[10]= 116388848574396158612596991763257135797979^m - m Out[10]=51835516.000000000000000000000000000000000000000000564045501599584517036465406 In[12]:= 111821958790102917465216066365339190906247589^m - m Out[12]= 188339125.99999999999999999999999999999999999999999999703503169989535000879619 In[33] := 8836529576862307317465438848849297054082798140^m - m Out[33] = 42800817.00000000000000000000000000000000000000000000000321239755400298680819416095288742420653229 In[71] := 532482704820936890386684877802792716774739424328^m - m Out[71] =924371800.999999999999999999999999999999999999999999999998143109316148796009581676875618489611792 In[21]:= 783358731736994512061663556662710815688853043638^m - m Out[21]= 993899177.0000000000000000000000000000000000000000000000022361744841282020 In[24]:= 8175027604657819107163145989938052310049955219905^m - m Out[24]= 1544126008.9999999999999999999999999999999999999999999999999786482891477\ 944981 19779617801396329619089113017251584634275124610667^m - m gives 1822929481.00000000000000000000000000000000000000000000000000187580971544991111083798248746369560. 130755944577487162248300532232643556078843337086375^m - m gives 2599324665.999999999999999999999999999999999999999999999999999689854836245815499119071864529772632. i.e.2, 599, 324, 665. 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 689 (51 consecutive 9 s) 322841040854905412176386060015189492405068903997802^m - m gives 3080353548.000000000000000000000000000000000000000000000000000019866002281287395703598786588650156 i.e. 3, 080, 353, 548. 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000,019 (52 consecutive 0 s) 310711937250443758724050271875240528207815041296728160^m - m gives 11195802709.99999999999999999999999999999999999999999999999999999960263763... i.e. 11,195,802,709. 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 602, 637,63 (55 consecutive 9s) 1465528573348167959709563453947173222018952610559967812891154^ m - m gives 200799291330.9999999999999999999999999999999999999999999999999999999999999900450730197594520134278 i. e 200, 799, 291, 330.999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 99 (62 consecutive 9 s). I did a little experimenting and found that the existence of such precise near integers from n^m-m is not specific to the MRB constant due to any internal quality, only due to the small value of m. You can find similarly precise approximations for n^x-x, where x is 1/E. 1/E(.37) has a value in the same neighborhood of the MRB constant (.19). Answer Posted 1 year ago  Well, I've tried 6,000,000 at least 5 times and am getting nowhere! I started a 5,555,555 digit computation on 19 Jun 2020 22 : 20 : 08, to break my bad luck spree: Here are my latest results:I'll only post 1 update a week, so as not to abuse the message board. Answer Posted 1 year ago  While the 5,555,555 digit calculation is working, I thought I would mention my latest mini-project. I wanted to look at computing the MRB constant, (0.18785964...) through a generalized continued fraction for z^(1/z).At Mathworld we see a suitable continued fraction here. 1 + (2 (x - 1))/(x^2 + 1 + ContinuedFractionK[-(n^2 x^2 - 1) (x - 1)^2, (2 n + 1) x (x + 1), {n, \[Infinity]}]) .It looks like. -With only 10 terms, I was able to calculate 4 decimals of the constant, 0.1878, the equivalent of adding up to 299,999 terms by brute force! N[1/2 - Sum[(-1)^x* {(2*(x - 1))/(ContinuedFractionK[ (x - 1)^2*(-(n^2*x^2 - 1)), (2*n + 1)*x*(x + 1), {n, 3}] + x^2 + 1) + 1}, {x, 1, 10^1}]] . -That gives 0.1878368104323782.See, N[Sum[(-1)^n (n^(1/n) - 1), {n, 1, 299999}]] gives 0.18783862276177388.It looks like the following.. - Answer Posted 1 year ago (You guessed it!) my 5,555,555 digit computation died from another long term power outage. I need a household generator! If I get a generator, I could calculate up to10,000,000 digits! P. S. Several times, I mentioned Crandall's first MRB constant Dirichlet's eta derivative formula: . I concluded with what I think is the fastest way of computing it in the message that starts out with " 4/22/2019". But there is something else I would like to test out: At https://www.sciencedirect.com/science/article/pii/S0022314X15001882 , there is the Adell-Lekuona scheme to quickly calculate the mth derivatives of eta of m. Stay tuned for what I find out!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Edit: I got some meager results of calculating the nth derivatives of eta of n from the Adell-Lekuona scheme: ## ... First I define c and the nth derivative of eta sub 1 of n from the scheme: c[t_, n_] := (-1.30.)^(n + t)* Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1.30.)^(n - l - j)*(Log[l + j + 1]/(l + j + 1))^t, {j, 0, n - l}], {l, 0,n}]; etad[t_] := (2/3)* NSum[c[t, n]/3^n, {n, 0, 20}, Method -> "AlternatingSigns", WorkingPrecision -> 30]  Then I compare the results with the actual derivatives: In[152]:= etad[2] - N[Derivative[n][DirichletEta][n] /. n -> 2, 30] Out[152]= -5.6495702147568955843*10^-12 In[153]:= etad[3] - N[Derivative[n][DirichletEta][n] /. n -> 3, 30] Out[153]= 3.4964879453028546174*10^-12 In[154]:= etad[4] - N[Derivative[n][DirichletEta][n] /. n -> 4, 30] Out[154]= -1.19233015142032460531*10^-12 In[168]:= etad[10] - N[Derivative[n][DirichletEta][n] /. n -> 10, 30] Out[168]= 3.859680615418530806797*10^-14 In[190]:= etad[100] - N[Derivative[n][DirichletEta][n] /. n -> 100, 30] Out[190]= -1.8845740316090756479036*10^-51  I'm getting more digits as the value of n goes up.. ## EDIT (3 days later) Here are more than 224 accurate digits of the MRB constant via only the Adell-Lekuona scheme in 44 min: First, I calculated 240 digits that have been proven to be correct to well beyond 224 digits:  In[132]:= m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 240, Method -> "AlternatingSigns"] Out[132]= \ 0.18785964246206712024851793405427323005590309490013878617200468408947\ 7231564660213703296654433107496903842345856258019061231370094759226630\ 4389293488961841208373366260816136027381263793734352832125527639621714\ 893217020762820621715167151756  Then I entered a line that computes the nth derivatives of eta of n:  c[t_, n_] := (-1240)^(n + t)*Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)* (N[Log[l + j + 1], 250]/(l + j + 1))^t, {j, 0, n - l}], {l, 0, n}]; etad[t_] := (2/3)*N[ Sum[c[t, n]/3^n, {n, 1, 500} ], 250]  Then I entered the program to compute the MRB constant from the derivatives:  Timing[shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 120}, Method -> "WynnEpsilon",WorkingPrecision -> 240, NSumTerms -> 90]]  Here are the time it took and the digits calculated:  {2656.11, \ 0.18785964246206712024851793405427323005590309490013878617200468408947\ 7231564660213703296654433107496903842345856258019061231370094759226630\ 4389293488961841208373366260816136027381263793734352832125527639621714\ 893217020762821}  Here those digits are proven to be correct to 224 digits:  In[138]:= m - shot Out[138]= 0.*10^-224  Compare with my fastest 224 digit computation, 62.5 milliseconds: In[72]:= Print["Start time is ", ds = DateString[], "."]; prec = 225; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*= 4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4, pc = Min[3 pc, pr/4]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[ Log[ll]/ ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(** N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 32]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Enter MRBtest2 to print ", Floor[Precision[MRBtest2]], " digits"]; m3M - MRB1 During evaluation of In[72]:= Start time is Mon 7 Sep 2020 03:19:21. During evaluation of In[72]:= Iterations required: 298 During evaluation of In[72]:= Will give 1 time estimates, each more accurate than the previous. During evaluation of In[72]:= Will stop at 2048 iterations to ensure precision of around 226 decimal places. During evaluation of In[72]:= Finished on Mon 7 Sep 2020 03:19:21. Processor time was 0.0625 s. During evaluation of In[72]:= Enter MRBtest2 to print \[Infinity] digits Out[78]= 0.*10^-224  That is 40,615 times faster. My use of the Adell-Lekuona scheme has a way to go. P.S. I did a lot of research and found out that my use of the Adell-Lekuona scheme is no faster, for up to around half a hundred digits than the following "brute force" one. And I show where it is a great deal slower! The scheme's main advantage seems to be being able to compute more of a maximum of digits (like the above 224, which to me seems impossible to match with a PC and general math software). In[45]:= m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100, Method -> "AlternatingSigns"]; Timing[ c1 = Limit[(-1)^n/n! Derivative[n][DirichletEta][x] /. n -> 1, x -> 1]; m + (c1 + NSum[(-1)^n/n! Derivative[n][DirichletEta][n], {n, 2, 30}, Method -> "WynnEpsilon", WorkingPrecision -> 100])] Out[45]= {7.84375, -2.40588*10^-48}  vs scheme: m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100, Method -> "AlternatingSigns"] Out[1]= 0.\ 1878596424620671202485179340542732300559030949001387861720046840894772\ 3156466021370329665443217278 In[41]:= c[t_, n_] := (-160)^(n + t)* Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)* (Log[l + j + 1]/(l + j + 1))^t, {j, 0, n - l}], {l, 0, n}]; etad[t_] := (2/3)* N[ Sum[c[t, n]/3^n, {n, 1, 90} ], 60] In[42]:= Timing[ shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 30}, Method -> "WynnEpsilon", WorkingPrecision -> 60, NSumTerms -> 60]] Out[42]= {12.5781, \ 0.187859642462067120248517934054273230055903094615556440737580} In[43]:= m - shot Out[43]= 2.84582345434425*10^-46  Answer Posted 1 year ago  Here are where the different types of programs for computing the MRB constant used here come from. From fastest to slowest for largest possible computations: my accelerated program called the MRB method (50,000 + digits) Crandall's 2012 accelerated program (50,000 + digits) fast eta programs, one as fast as Crandall's program (50,000 + digits), followed by n^(1/n) brute force addition (100 + digits) when using common acceleration methods such as MMA's "AlternatingSigns." Integral calculations Adell-Lekuona eta scheme used for etas which are then summed through brute force (100 + digits), brute force eta addition (50 - digits) brute force eta addition (100 + digits), Adell-Lekuona eta scheme (50 - digits) n^(1/n) brute force addition without any acceleration (1 + digits) You can use your browsers "find function" for the following.The MRB method can be found in the message that starts with "Tue 24 Apr 2018".The original Crandall 2012 accelerated program is found at the post that starts with "Crandall is not using his eta formulas directly!!!!!!! ".The fast eta program that is as fast (or almost as fast) as Crandall's 2012 is found in the message that starts with "4/22/2019".For the most part, the other fast eta programs are found in the message that begins with "Jan 2015"", the one that begins with "Talking about the eta formula for the MRB constant" and the one that begins with "02/12/2019".One integral calculation formula is seen in the message that starts with "On 2/24/2020 at 4:35 pm, I started a 10,000 digit calculation of the MRB constant using the integral".The Adell-Lekuona eta scheme and brute force eta addition can be found in the message that begins with "(You guessed it!) my 5,555,555 digit computation died from another long term power outage. "Among many other places, n^(1/n) brute force addition (100 + digits) when using common acceleration methods such as MMA's "AlternatingSigns." can be found in the paragraph that starts with "I computed exactly 300,000 digits to the right of the decimal point".An example of n^(1/n) brute force addition without any acceleration would be N[Sum[(-1)^n *(n^(1/n) - 1), {n, 1, 10^6}]] which is correct to to almost 5 decimal places. Answer Posted 1 year ago ## The Seventh attempt at Calculating 6,000,000 digits Speaking of methods of computation, at Fri 11 Sep 2020 21:41:41, I started my seventh attempt at calculating 6,000,000 digits of the MRB constant with one node of the MRB constant supercomputer. Here are the MRB method program and recent output. Print["Start time is ", ds = DateString[], "."]; prec = 6000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*= 4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precision of around ", pr, " decimal places."]; Print[]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4, pc = Min[3 pc, pr/4]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[ Log[ll]/ ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(** N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 32]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc , " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end* chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[MRB1]], " digits. The error from a 5,000,000 or more digit calculation \ that used a different method is "]; N[MRB - MRB1, 20]   As of Sat 19 Sep 2020 09:00:54 there were 356352 iterations done in 6.4555*10^5 seconds. That is 0.55201 iterations/s. 4.476460% complete. It should take 166.890 days or 1.442*10^7s, and finish Thu 25 Feb 2021, 19:03:08.  See https://www.wolframcloud.com/obj/bmmmburns/Published/MRB%202020.nb for up-to-date notebook. Due to a battery backup that surged, the MRB constant supercomputer suffered great damage, and of course, the computation failed. Answer Posted 1 year ago  Well, I rebuilt the MRB constant supercomputer stronger than ever. I will call it the MRB constant supercomputer 2. Here is how it looks:Here is where I posted its progress compared to some previous computers. It broke all new records for large computations!Here are the documenting notebooks for the MRB constant supercomputer timings and computation times:https://www.wolframcloud.com/download/bmmmburns/Published/MRBSC 1.nbhttps://www.wolframcloud.com/download/bmmmburns/Published/MRBSC 2.nb1 million digits took 44 hours, as recorded in the attached "44 hour million.nb".Since I've prepared a lot of redundancy into the MRB constant supercomputer 2, I rushed ahead and started the 8th attempt at 6,000,000 digits with half of its nodes. I'll post a few updates here, and if it looks like I will be successful, I will move all the updates to a new reply. Wish me luck!The code that I'm using is the same one found in the reply that starts with "4th Try at 6,000,000 (6 million) Digits" Here is the latest update on the Wolfram could:The computers went offline. With 16 kernels and 16 active cores, Ii would have taken 116 days.Nonetheless, I did get some great new records for documented computation times while using V12.1: Proof in the attached "MRBSC2speedrecordsforV12.1.nb".Don'tlook now, but I'm trying 6,000,000 again. Here is a portion of the notebook: Out[3]= {"KernelObject"[1, "DigitalStorm-PC"], "KernelObject"[2, "DigitalStorm-PC"], "KernelObject"[3, "DigitalStorm-PC"], "KernelObject"[4, "DigitalStorm-PC"], "KernelObject"[5, "DigitalStorm-PC"], "KernelObject"[6, "DigitalStorm-PC"], "KernelObject"[7, "DigitalStorm-PC"], "KernelObject"[8, "DigitalStorm-PC"], "KernelObject"[9, "DigitalStorm-PC"], "KernelObject"[10, "DigitalStorm-PC"], "KernelObject"[11, "DigitalStorm-PC"], "KernelObject"[12, "DigitalStorm-PC"], "KernelObject"[13, "WIN-1AA39U1LQNT"], "KernelObject"[14, "WIN-1AA39U1LQNT"], "KernelObject"[15, "WIN-1AA39U1LQNT"], "KernelObject"[16, "WIN-1AA39U1LQNT"], "KernelObject"[17, "WIN-1AA39U1LQNT"], "KernelObject"[18, "WIN-1AA39U1LQNT"], "KernelObject"[19, "WIN-1AA39U1LQNT"], "KernelObject"[20, "WIN-1AA39U1LQNT"], "KernelObject"[21, "local"], "KernelObject"[22, "local"], "KernelObject"[23, "local"], "KernelObject"[24, "local"], "KernelObject"[25, "local"], "KernelObject"[26, "local"], "KernelObject"[27, "local"], "KernelObject"[28, "local"], "KernelObject"[29, "local"], "KernelObject"[30, "local"], "KernelObject"[31, "local"], "KernelObject"[32, "local"], "KernelObject"[33, "local"], "KernelObject"[34, "local"], "KernelObject"[35, "local"], "KernelObject"[36, "local"]} In[4]:= Print["Start time is ", ds = DateString[], "."]; prec = 6000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/396288]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/65536, pc = Min[3 pc, pr/65536]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/99072]**) x = SetPrecision[x, pr/16384]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16384] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16384] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/4096]*)x = SetPrecision[x, pr/4096]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4096] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4096] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/4096]*)x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/1024]*)x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/256]*)x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/64]**)x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/16]**)x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/ ll],pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc, " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[ MRB1]], " digits. The error from a 5,000,000 or more digit \ calculation that used a different method is "]; N[MRB - MRB1, 20] During evaluation of In[4]:= Start time is Tue 20 Oct 2020 09:19:39. During evaluation of In[4]:= Iterations required: 7959598 During evaluation of In[4]:= Will give 3887 time estimates, each more accurate than the previous. During evaluation of In[4]:= Will stop at 7960576 iterations to ensure the precision of around 6029999 decimal places. The computers went offline. With 36 kernels and 26 active cores, it would have taken 83 days.Now, I'm using the same code and setup, with prec=1000000, to try to break my 44 hour 1 million digits record.That attempt using the maximum number of kernels allowed over my finite number of cores was no faster than using equal cores and kernels. That is in accordance with Wolfram's suggestions.I'm not sure what to do next -- will try to make some progress, somehow and report back then. Attachments: Answer Posted 1 year ago  I said, "would get back to you when I made some progress." Well here's what I did. 1 node of the MRB constant supercomputer is calculating 6 million digits using the same program used above. Another node is calculating 7,500,000 digits using an experimental, faster program, which digits I will round down to 7,000,000. The remaining node is calculating 5,500,000 digits using only Richard Crandall's original algorithm. If they all three agree to 5,500,000 digits, I will be certain that those digits are correct. And if the 6,000,000 are the same found in the rounded down 7,500,000, will be pretty-well satisfied that they are correct. And experience has taught me that the last one is probably correct to 7,000,000 or more.The 5,500,000 digits computation using only Crandall's original method can be found here: https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nb .The 6,000,000 digits computation using my method found in the previous message, here: https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nb The 7,500,000 digits computation using the experimental, faster method, here: https://www.wolframcloud.com/obj/bmmmburns/Published/first2%207%20million%2011p3.nb .The node tasked with the 7,500,000 digits computation using the experimental, faster method crashed, so I reassigned it 6,500,000 digits using my proven method. It is now found here: . Answer Posted 1 year ago  It's been a while since I checked in with you all, so here is an encouraging update! The 5,500,000 digits computation using only Crandall's original method can be found here: https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nbThe latest output is In[85]:= DateString[]  5235200 iterations in 1.13741582450835*10^7 seconds. "Thu 4 Mar 2021 08:03:45" 70.6928% done.  The 6,500,000 digits using my proven method.:https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC26p5million.nbThe latest output is  As of Thu 4 Mar 2021 07:53:12 there were 4317184 iterations done in 9.2996*10^6 seconds. That is 0.46423 iterations/s. 50.05937% complete. It should take 214.983 days or 1.857*10^7s, and finish Sat 19 Jun 2021 16:14:58.  The 6,000,000 digits computation using my method found in the previous messages, here: https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nbThe latest output is As of Thu 4 Mar 2021 08:47:02 there were 6662144 iterations done in 1.1599*10^7 seconds. That is 0.57435 iterations/s. 83.68922% complete. It should take 160.398 days or 1.386*10^7s, and finish Tue 30 Mar 2021 12:16:52. P.S as of 04:00 am 1/2/2021, this discussion had 300,000 views!And as of 08:30 pm 2/3/2021, this discussion had 330,000 views! Answer Posted 9 months ago ## Update on the 6,000,000 digit computation. I'm getting so close, I can taste the victory!!!!! Latest output: As of Mon 15 Mar 2021 18:20:22 there were 7221248 iterations done in 1.258410^7 seconds. That is 0.57383 iterations/s. 90.71263% complete. It should take 160.543 days or 1.38710^7s, and finish Tue 30 Mar 2021 15:45:20. Answer Posted 8 months ago # I DECLARE VICTORY! I computed 6,000,000 digits of the MRB constant, finishing on Tue 30 Mar 2021 22:02:49. The MRB constant supercomputer 2 said the following:  Finished on Tue 30 Mar 2021 22:02:49. Processor and actual time were 5.28815859375*10^6 and 1.38935720536301*10^7 s. respectively Enter MRB1 to print 6029991 digits. The error from a 5,000,000 or more digit calculation that used a different method is 0.*10^-5024993  That means that the 5,000,000 digit computation was actually accurate to 5024993 decimals!!! For the complete blow-by-blow see MRBSC2 6 million 1st fourth.nb. Attachments: Answer Posted 8 months ago # Distribution of digits Here is the distribution of digits within the first 6,000,000 decimal places (.187859,,,), "4" shows up more than other digits, followed by "0," "8" and "7." Here is the distribution of digits within the first 5,000,000 decimal places (.187859,,,), "4" shows up a lot more than other digits, followed by "0," "8" and "6." Here is a similar distribution over the first 4,000,000: 3,000,000 digits share a similar distribution: Over the first 2 and 1 million digits "4" was not so well represented. So, the heavy representation of "4" is shown to be a growing phenomenon from 2 million to 5 million digits. However, "1,2,and 5" still made a very poor showing: I attached more than 6,000,000 digits of the MRB constant. Attachments: Answer Posted 8 months ago  The MRB constant supercomputer 2 is still working on 6,500,000 and 5,500,000 digit computations. The latest output on the 6,500,000 digit computation is As of Sun 11 Apr 2021 18:04:26 there were 5810176 iterations done in 1.2619*10^7 seconds. That is 0.46041 iterations/s. 67.37117% complete. It should take 216.766 days or 1.873*10^7s, and finish Mon 21 Jun 2021 11:03:14. The 5,500,000 is being done by a totally different method. Its latest output is 6686208 iterations in 1.46938392445428*^7 seconds. 90.27240044247787% done. When they are complete we will know for a fact what 5,500,000 digits of the MRB constant are! If the 6,500,000 digit computation gives the same answer as the 6,000,000 digit computation, experience has taught us, there is no reason to doubt it will be right. Answer Posted 7 months ago  Probably the last update on the 5,500,000 digit computation: Print[7211520/7405568*100., "% done."] 97.37970132743364% done. When it is done, having the same first 5,500,000 digits found in the previous 6,000,000 digit computation by a totally different method, it will prove beyond any shadow of a doubt the 5,500,000 digits are correct.Stay tuned! Answer Posted 7 months ago  Beyond any shadow of a doubt, I verified 5,609,880 digits of the MRB constant on Thu 4 Mar 2021 08:03:45. The 5,500,000+ digit computation using a totally different method showed about that many decimals in common with the 6,000,000+ digit computation. The method for the 6,000,000 run is found in a few messages above in the attached notebook titled "MRBSC2 6 million...nb." Print["Start time is ", ds = DateString[], "."]; prec = 6000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/396288]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; (**N[Exp[Log[ll]/ll],pr/396288]**) pc = iprec; While[pc < pr/65536, pc = Min[3 pc, pr/65536]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/65536]**) x = SetPrecision[x, pr/16384]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16384] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16384] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr/16384]*) x = SetPrecision[x, pr/4096]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4096] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4096] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr/4096]*) x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) -SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ ll]/ll],pr/1024]*) x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ ll]/ll],pr/256]*) x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ ll]/ll],pr/64]**) x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ ll]/ll],pr/16]**) x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ll]/ll],pr/4]**) x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc, " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[ MRB1]], " digits. The error from a 5,000,000 or more digit \ calculation that used a different method is "]; N[MRB - MRB1, 20] The 5,500,000+digit run is found below in the attached "5p5million.nb," including the verified 5,609,880 digits. (*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 5500000;(*Number \ of required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; (*N[Exp[Log[ll]/ll], pr/27]*) pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (*N[Exp[Log[ll]/ll], pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; N[MRBtest2 - MRB, 20]  Attachments: Answer Posted 7 months ago Previously, I computed and confirmed to the point where I had no doubt of the accuracy a little over 5,500,000 digits. Presently, I am computing and not just confirming, but proving to be accurate through a parity check, 6,500,000 digits of the MRB constant. I started the computation Mon 16 Nov 2020 at 16:39:39 and that should be done sometime around June 23, 2021. I hope to get the parity check proving part done in less than 1 year. (I will give you updates on that.) ## Update If all goes well, the parity check will be complete by Wednesday, June 22, 2022. ## Update The computation stopped giving outputs for me, so I had to restart it. That won't affect the completion of the parity check, however. The computation, from the Burns-Crandal Method, is found in the attached "MRBSC26p5million.nb." Print["Start time is ", ds = DateString[], "."]; prec = 6500000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/396288]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/65536, pc = Min[3 pc, pr/65536]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/99072]**) x = SetPrecision[x, pr/16384]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16384] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16384] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/4096]*)x = SetPrecision[x, pr/4096]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4096] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4096] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/4096]*)x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/1024]*)x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/256]*)x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/64]**)x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/16]**)x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/ ll],pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc, " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[ MRB1]], " digits. The error from a 5,000,000 or more digits calculation that used a different method is "]; N[MRB - MRB1, 20]  The verification, using the Crandal nontrivial MRB constant identity, , is found in the attached "6p5 million eta verification.nb." Print["Start time is ", ds = DateString[], "."]; prec = 6500000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{lg, a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*= 4*number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.0002 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = pr/2^6; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; lg = N[Log[ll], iprec]; x = N[E^(lg/ll), iprec]; pc = iprec; While[pc < pr, pc = Min[4 pc, pr]; x = SetPrecision[x, pc]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pc] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, 2 pc] ll (ll - 1)/(3 ll t2 + t^3 z))]; x - N[Log[ll], prec]/ll, {l, 0, tsize - 1}], {j, 0, cores - 1}]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-10)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st - stt, 4], " seconds.", " Should take ", N[ti, 4], " days or ", ti*3600*24, "s, finish ", DatePlus[ds, ti], "."], Print["Denominator computed in ", stt = st, "s."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBeta2toinf = expM[prec];]; Print["Finished on ", DateString[], ". Processor and total time were ", t2[[1]], " and ", st, " s respectively."];  MRBeta1 = EulerGamma Log[2] - 1/2 Log[2]^2  # MRB is 6, 500, 000 digits computed through the Burns-Crandall method N[MRBeta2toinf + MRBeta1 - MRB, 10] ` Attachments: Answer Posted 7 months ago  The power at my house went off for several hours, and both computations failed. I'm going to wait until I find a way to prove 6,500,000 to be accurate in less way less than a year. In principle, I have already proven my and Crandall's method to be accurate by way of the eta formulas in the message that starts with " 4/22/2019". At the top of this discussion, I shared thorough proof that the eta formula and the formula behind our methods are equal. And in the message that starts with "Beyond any shadow of a doubt, I verified", I showed that my 5,500,000 digits of the MRB were correct by computing it through 2 different methods. So as the situation stands, my 6,000,000 digits, shown in the reply that begins with "I DECLARE VICTORY!" are more likely to be correct than incorrect. Answer Posted 6 months ago  I just discovered a new integral for the MRB constant (CMRB). It would be nice to find an integral that converges faster than the sum! Correction: The integral in does converge way faster than the sum. After 100,000 terms the sum converges to around 5 or 6 decimal places in 1.2 seconds. Where on the same computing device the integral computes around 339 decimal places in 2/3 the time. Answer Posted 6 months ago  The following is a way to compute the MRB constant (CMRB) through an integral without using imaginary parts, without much loss in speed, followed by a new MRB constant integral (using Re[] instead of Im[]).It also is a tutor in$(1+ i t)^{1+i t}.\$ Finally, we show many MRB constant-related integrals, from as simple asto as complicated as
Posted 4 months ago
 Here is my best guess of the time complexity of the various programs in this post, using the fact that Steven Finch wrote that "the summing of the terms of the MRB constant is on the order of O(N^2/LogN)" for a base and adjusting the order by how much faster each program is. This might not be right; it is just how they seem.
Posted 3 months ago