# Try to beat these MRB constant records!

Posted 8 years ago
663923 Views
|
63 Replies
|
17 Total Likes
|

## The MRB constant: ALL ABOARD!

POSTED BY: Marvin Ray Burns.

CMRB is defined at

# Content of this first post, as of May 24, 2022

1. How it all began
2. The why and what of the CMRB Records,
3. CMRB and its applications,
4. MeijerG Representation for CMRB,
5. CMRB formulas and identities,
6. Primary Proof 1,
7. Primary Proof 2,
8. Primary Proof 3,
9. The relationship between CMRB and its integrated analog,
10. The MRB constant supercomputer 0

## Second post:

The following might help anyone serious about breaking my record.

## Third post

The following email Crandall sent me before he died might be helpful for anyone checking their results.

## Fourth post

Perhaps some of these speed records will be easier to beat.

## Many more interesting posts

...including the MRB constant supercomputers 1 and 2.

...including records of computing the MRB constant from Crandall's eta derivative formulas.

...including all the methods used to compute CMRB and their efficiency.

...including the dispersion of the 0-9th decimals in CMRB decimal expansions.

...including the convergence rate of 3 major different forms of CMRB.

...including complete documentation of all multimillion-digit records with many highlights.

...including arbitrarily close approximation formulas for CMRB.

...including efficient programs to compute the integrated analog (MKB) of CMRB.

...including an incredible 7 million digits on 1/4 of MRB constant supercomputer 3 (10 cores at 5.2 GHz and Ram, 64 GB 3200 MHz RAM dedicated to those 10 cores).

...including a recent discovery that could help in verifying digital expansions of the integrated analog (MKB) of CMRB.

...including an incredible 10 million digits on 3/4 of MRB constant supercomputer 3 (30 cores at 5.2 GHz and 224 GB 4800 MHz RAM dedicated to those 30 cores), using an algorithm with a 4th degree convergence rate. .

# How it all began

From these meager beginnings:

I was a D and F student through 6th grade the second time, but in Jr high, in 1976, we were given a self-paced program. Then I noticed there was more to math than rote multiplication and division of 3 and 4-digit numbers! Instead of repetition, I was able to explore what was out there. The more I researched, the better my grades got! It was amazing!! So, having become proficient in mathematics during my high school years, on my birthday in 1994, I decided to put down the TV remote control and pick up a pencil. I began by writing out the powers of 2, like 2*2, 2*2*2, etc. I started making up algebra problems to work at solving, and even started buying books on introductory calculus.
Then came my first opportunity to attend university. I took care of my mother, who suffered from Alzheimer's, so instead of working my usual 60+ hours a week. I started taking a class or two a semester. After my mom passed away, I went back to working my long number of hours but always kept up on my math hobby!
Occasionally, I make a point of going to school and taking a class or two to enrich myself and my math hobby. This has become such a successful routine that some strangers listed me on Wikipedia as an amateur mathematician alphabetically following Jost Bürgi who constructed a table of progressions that is now understood as antilogarithms independently of John Napier at the behest of Johannes Kepler.
I have studied a few graduate-level topics in Mathematics but have yet to earn my Bachelor's, which I intend to work on in the coming year while still working full-time.


From these meager beginnings:

On January 11 and 23,1999 I wrote,

I have started a search for a new mathematical constant! Does anyone want to help me? Consider, 1^(1/1)-2^(1/2)+3^(1/3)...I will take it apart and examine it "bit by bit." I hope to find connections to all kinds of arithmetical manipulations. I realize I am in "no man's land," but I work best there! If anyone else is foolhardy enough to come along and offer advice, I welcome you.


I came to find out that this constant (CMRB)

was more closely related to other constants than I could have imagined:

For example, consider its relationship to Viswanath's constant (VC) With both being functions of x1/x alone, we have these approximations:

In 2016 I found ==3.57*10^-11.

In[232]:= (-801233750 + 459067873 \[Pi] -
827447500  CMRB \[Pi])/134832500 - VC

Out[232]= 3.57*10^-11


The following two much simpler ones, with the memory of Zeta(2) = Pi^2/6 and Pi/2≈11/7, bear some resemblance to a would-be limit-sum analog to the Abel-Plana integral-sum equations :

In[2]:= Reduce[w Exp[w] == 1, w]

Out[2]= C[1] \[Element] Integers && w == ProductLog[C[1], 1]


The Mathematica code and result:

 VC = 1.1319882487943061;

CMRB = 0.1878596424620671202485179 ;

VC/(6(ProductLog[E]))-CMRB

(* 0.00080506567032*).

VC/(66/7-6ProductLog[1])-CMRB

(* 3.416388*^-8*).


It is difficult to describe any such analog thus far, though. I believe they are approximations rather than equations. Nonetheless, they are ratios of integers and named constants.

But wait, there is more to this Viswanath's-MRB constant "relationship:"

and

Here are those codes:

CMRB = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity},
WorkingPrecision -> 20, Method -> "AlternatingSigns"];
For[n = 1, n < 10,
Print[WolframAlpha[ToString[N[((56/5)*CMRB)^(1/n), 10]],
"PodCells"][[6]]], n++]


and

Clear[a]; VC = 1.131988248794306114; CMRB = 0.1878596424620671202485179;
Table[a[n] = CMRB - n VC/56; {a[n], "-CMRB", n, "*VC^6/56=",
p = Rationalize[a[n]/CMRB, 1/100], "CMRB=", N[p CMRB, 10]}, {n, 1, 9}] // TableForm


So, are the division and surd approximations related? I don't know, but their ratio is approximately Gelfond's constant $=e^\pi.$

In[120]:= a=CMRB-(5 VC^6)/56

Out[120]= 1.4726*10^-9

In[121]:= b=VC/(6 (11/7-W(1)))-CMRB

Out[121]= 3.416573*10^-8

In[122]:= b/a

Out[122]= 23.201

In[123]:= N[E^\[Pi]]

Out[123]= 23.1407


Here are more details about the approximations' so-called relationship (how sensitive the pair are).

From these meager beginnings:

On Feb 22, 2009, I wrote,

It appears that the absolute value, minus 1/2, of the limit(integral of (-1)^x*x^(1/x) from 1 to 2N as N->infinity) would equal the partial sum of (-1)^x*x^(1/x) from 1 to where the upper summation is even and growing without bound. Is anyone interested in improving or disproving this conjecture?


I came to find out it is a very slow to converge ocellary integral that could later be looked up in Google Scholar.

After I mentioned it to him, Richard Mathar published his meaningful work on it here in arxiv, where M is the MRB constant and M1 is MKB:

I developed a lot more theory behind it and ways of computing many more digits in this linked Wolfram post.

Here is how my analysis (along with improvements to Mathematica) has improved the speed of calculating that constant's digits:

(digits and seconds)

[ 2015 ]                                                [ 2021  Method ]
V 10.1.2   V10.3       v11.3   V12.0         V12.1         V12.3       V13.0
1000                                                                    3.3        3.1
2000        437      256            67      67           58            21          20
3000        889      794           217     211          186           84            ?
4000                   1633         514     492          447           253*          259 (248*)
5000                  2858         1005    925          854           386          378
10000                 17678         8327    7748        7470          2800         2748
20000                 121,431       71000   66177
40000                                      362,945                   148,817      134,440

* means from a fresh kernel.


From these meager beginnings:

On Sat, 6 Feb 2010, it came to me to ask what value of $a$ gives $$\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-a)=0\text{ ?}$$(For what value of a is the Levin's u-transform's and Cesàro's sum result 0 considering weak convergence?)

$C$MRB is approximately 0.1878596424620671202485179340542732. See this and this.

$\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-a)$ is formally convergent only when $a =1$. However, if you extend the meaning of $\sum$ through "summation methods", whereby series that diverge in one sense converge in another sense (e.g. Cesaro, etc.) you get results for other $a$.

The solution I got surprised me: it was $a=1-2\times C\mathrm{MRB}=0.6242807150758657595029641318914535398881938101997224\ldots$. Where $C\mathrm{MRB}$ is $\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-1)$.

To see this for yourself in Mathematica enter FindRoot[NSum[(-1)^n*(n^(1/n) - x), {n, 1, Infinity}], {x, 1}] where regularization is used so that the sum that formally diverges returns a result that can be interpreted as evaluation of the analytic extension of the series.

I wrote Mathematica to find out what method is used and they replied:

From Marvin Ray Burns bmmmburns@sbcglobal.net Date: Sat, 6 Feb 2010 21:03:54 -0600 Subject: Premier Service Help Form To: support@wolfram.com

Name:        Marvin Ray Burns Email:        ******.net Organization: IUPUI License:      L***** Version:  6 OS:          "Windows"
Suggestion or Bug: I am writing about the "AlternatingSigns" Method in  NSum. Consider the Divergent series NSum[(-1)^n*(n^(1/n) - a), {n, Infinity}, Method -> "AlternatingSigns"], where Abs[a]<1. Strangely, Mathematica does compute a value for many of those series. Obviously, the algorithms used in the "AlternatingSigns" Method produce a value independently of the fact that the series is divergent. Perhaps one should not be surprised that a value is returned but IT SHOULD BE MADE CLEAR WHAT THAT VALUE REPRESENTS! What is the meaning of that value given that its series is divergent? From my experiments in V7 that value is not reproducible with Sum[, Regularization-> ].


Hello,

Thank you for the email.

Note that in V7, you may also try these:b In[11]:= Sum[(-1)^n*(n^(1/n) - 0.624277766757), {n, Infinity},Method -> "AlternatingSigns"]b> During evaluation of In[11]:= Sum::div:Sum does not converge. >>b Out[11]= Sum[(-1)^n*(-0.624277766757 + n^(1/n)), {n, Infinity},  Method -> "AlternatingSigns"]In[33]:= Sum[(-1)^n*(n^(1/n) - 0.624277766757), {n, Infinity}] During evaluation of In[33]:= Sum::div:Sum does not converge. >>  Out[33]= Sum[(-1)^n*(-0.624277766757 + n^(1/n)), {n, Infinity}]  Thank you for taking the time to send us this report. I have forwarded  your examples to our development group.  We apologize for any inconvenience caused by this problem.


I have included your contact information so that you can be notified when this has been resolved.

Sincerely,

*******, Ph.D. Technical Support Wolfram Research, Inc. http://support.wolfram.com

 Thank you for your email.  If you do not specify a Method for NSum it will try to choose between the EulerMaclaurin or WynnEpsilon methods. In any case, some implicit assumptions about the functions you are summing have to be made. If these assumptions are not correct, you may get inaccurate answers.


Numerical Sums and Products f the ratio test does not give 1, the Wynn epsilon algorithm is applied to a sequence of partial sums or products. Otherwise Euler[Dash]Maclaurin summation is used with Integrate or NIntegrate.

1-2$C$MRB is what I call Ma. Here is the formula for Ma by way of Levin-Type Sequence Transformations: in Maple

Digits := 20; fsolve(sum((-1)^j*(j^(1/j)-a), j = 1 .. infinity) = 0, a),


giving 0.62428071507586575950,

and in Mathematica,

Block[{$MaxExtraPrecision = 10000}, FindRoot[NSum[(-1)^j*(j^(1/j) - a), {j, Infinity}], {a, 0.6}, WorkingPrecision -> 20]]  giving {n -> 0.62428071507608096085}. There is a discrepancy between the two results, but they do agree that Ma is approximately = 0.624280715076. Finally let a = Ma =$1-2C$MRB = 0.6242807150758... and the two limit-points of the series$\sum_{n=1}^\infty (-1)^n(n^{1/n}-Ma)$are +/-$C$MRB with its Levin's u-transform's result being 0. See the integer sequence here. At about the same time, I noticed the following when I extend the meaning of$\sum$through "summation methods", whereby series that diverge in one sense converge in another sense (e.g. Cesaro, etc.)  Let$c=$MRB constant;$x$, and$y =$any number, then it can be shown that $$\sum_{n=1}^\infty (-1)^n(x n^{1/n}+y n)=(c-1/2) x-\frac14 y$$ From these meager beginnings: In October 2016, I wrote the following here in researchgate: First, we will follow the path the author took to find out that for  the limit of the ratio of a to a - 1, as a goes to infinity is Gelfond's Constant, (e ^ pi). We will consider the hypothesis and provide hints for proof using L’ Hospital’s Rule (since we have indeterminate forms as a goes to infinity). We find there is no limit a goes to infinity of the ratio of the previous forms of integrals when the "I" is left out, and give a small proof for their divergence.  That was responsible for the integral-equation-discovery mention in a following post, where it is written, "Using those ratios, it looks like" (There m is the MRB constant.) # MRB Constant Records, My inspiration to compute a lot of digits of CMRB came from the following website by Simon Plouffe. There, computer mathematicians calculate millions, then billions of digits of constants like pi, when with only 65 decimal places of pi, we could determine the size of the observable universe to within a Planck length (where the uncertainty of our measure of the universe would be greater than the universe itself)! In contrast 65 digits of the MRB constant "measures" the value of -1+ssqrt(2)-3^(1/3) up to n^(1/n) where n is 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000, which can be called 1 unvigintillion or just 10^66. And why compute 65 digits of the MRB constant? Because that is the only way to solve such a problem as1465528573348167959709563453947173222018952610559967812891154^ m-m, which gives 200799291330.9999999999999999999999999999999999999999999999999999999999999900450... And why compute millions of digits of it? uhhhhhhhhhh.... "Because it's there!" (...Yeah, thanks George Mallory!) And why?? (c'est ma raison d'être!!!)  So, below you find reproducible results with methods. The utmost care has been taken to assure the accuracy of the record number of digits calculations. These records represent the advancement of consumer-level computers and clever programming over the past 23 years. Here are some record computations of CMRB. If you know of any others let me know, and I will probably add them! 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, was computed. That first digit, by the way, was just 0. Then by using the sum key, to compute$\sum _{n=1}^{1000 } (-1)^n \left(n^{1/n}\right),$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.  4 decimals(.1878) of CMRB were computed on Jan 11, 1999 with the Inverse Symbolic Calculator, applying 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).  5 correct decimals (rounded to .18786), in Jan of 1999 were drawn from CMRB using Mathcad 3.1 on a 50 MHz 80486 IBM 486 personal computer operating on Windows 95.   9 digits of CMRB shortly afterward 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.   500 digits of CMRB with an online tool called Sigma on Jan 23, 1999. See [http://marvinrayburns.com/Original_MRB_Post.html][42] if you can read the printed and scanned copy there.  5,000 digits of CMRB in September of 1999: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.   6,995 accurate digits of CMRB were computed on June 10-11, 2003 over a period, of 10 hours, on a 450 MHz P3 with an available 512 MB RAM,.  8000 digits of CMRB completed, using a Sony Vaio P4 2.66 GHz laptop computer with 960 MB of available RAM, at 2:04 PM 3/25/2004,   11,000 digits of CMRB on March 01, 2006, with a 3 GHz PD with 2 GB RAM available calculated.   40, 000 digits of CMRB in 33 hours and 26 min via my program written in Mathematica 5.2 on Nov 24, 2006. The computation was run on a 32-bit Windows 3 GHz PD desktop computer using 3.25 GB of Ram. The program was 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]]   60,000 digits of CMRB on July 29, 2007, at 11:57 PM EST 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.  65,000 digits of CMRB in only 50.50 hours on a 2.66 GHz Core 2 Duo using 64-bit Windows XP on Aug 3, 2007, at 12:40 AM EST, Max memory used was 5.0 GB of RAM.  100,000 digits of CMRB on Aug 12, 2007, at 8:00 PM EST, 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.   150,000 digits of CMRB on Sep 23, 2007, at 11:00 AM EST. 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.   200,000 digits of CMRB using Mathematica 5.2 on March 16, 2008, at 3:00 PM EST,. Found 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.  300,000 digits of CMRB were destroyed (washed away by Hurricane Ike ) on September 13, 2008 sometime between 2:00 PM - 8:00 PM EST. 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 is 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]]


225,000 digits of CMRB were started with a 2.66 GHz Core 2 Duo using 64-bit Windows XP on September 18, 2008. It was completed in 1072 hours.


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. The Max memory used was 60.5 GB.


 250,000 digits of CMRB on Jan 29, 2009, 1:26:19 pm (UTC-0500) EST, 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.


  300000 digit search of CMRB was initiated using an i7 with 8.0 GB of DDR3 RAM onboard on Sun 28 Mar 2010 21:44:50 (UTC-0500) EST, but it failed due to hardware problems.


  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) Which 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.


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[]


1,000,000 digits of CMRB  for the first time in history in 18 days 9 hours 11 minutes 34.253417 seconds by Sam Noble of the Apple Advanced Computation Group.


1,048,576 digits in a lightning-fast 76.4 hours. Finishing on Dec 11, 2012 were scored by Dr Richard Crandall, an Apple scientist and head of its advanced computational group. That's on a 2.93 GHz 8-core Nehalem.

To beat that, on Aug of 2018, I computed 1,004,993 digits of CMRB in 53.5 hours 34 hours computation time (from the timing command) 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.

To beat that, on Sept 21, 2018: I computed 1,004,993 digits of CMRB in 50.37 hours of absolute time and 35.4 hours of computation time (from the timing command) with 18  (DDR3 and DDR4) processor cores!  Search this post for "50.37 hours" for documentation.**

To beat that, on May 11, 2019, I computed over 1,004,993 digits, in 45.5 hours of absolute time and only 32.5 hours of computation time, using 28 kernels on 18 DDR4 RAM (of up to 3200 MHz) supported cores overclocked up to  5.1 GHz  Search 'Documented in the attached ":3 fastest computers together 3.nb." '  for the post that has the attached documenting notebook.

To beat that, I accumulated over 1,004,993 correct digits of CMRB in 44 hours of absolute time and 35.4206 hours of computation time  on 10/19/20, using 3/4 of the MRB constant supercomputer 2 -- see [https://www.wolframcloud.com/obj/bmmmburns/Published/44%20hour%20million.nb][43]  for documentation.

To beat that I did a 1,004,993 correct digits computation in 36 hours of absolute time and only 26 hours of computation time, on Sun 15 May 2022 at 06:10:50, using 3/4  of the MRB constant supercomputer 3. Ram Speed was 4800MHz and all of the 30 cores were clocked at up to 5.2 GHz.


 A little over 1,200,000 digits, previously, of CMRB in 11   days, 21 hours, 17 minutes, and 41 seconds (I finished on March 31, 2013, using a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz.


2,000,000 or more digit computation of CMRB on May 17, 2013, 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.


 3,014,991 digits of CMRB,  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.


 Over 4 million digits of CMRB was finished on Wed 16 Jan 2019 19:55:20.
It took 4 years of continuous tries. This successful run took 65.13 days absolute 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.

Example use of M R Burns' algorithm to compute 123456789^(1/123456789) 10,000,000 digits:

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}



 More than 5 million digits of CMRB were found on Fri 19 Jul 2019 18:49:02,   Methods described in the reply below which begins with "Attempts at a 5,000,000 digit calculation ."   For this 5 million digit calculation of MRB using the 3 node MRB supercomputer: processor time was 40 days. and the actual time was 64 days.   That is in less absolute time than the 4-million-digit computation which used just one node.


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 at 22:02:49 in 160 days.
The MRB constant supercomputer 2 said the following:
Finished on Tue 30 Mar 2021 22:02:49. computation and absolute 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!!!


5,609,880, verified by 2 distinct algorithms for x^(1/x), digits of the MRB constant on Thu 4 Mar 2021 at 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.


6,500,000 digits of the MRB constant on my second try,

The MRB constant supercomputer said,

Finished on Wed 16 Mar 2022 02: 02: 10. computation and absolute time
were 6.26628*10^6 and 1.60264035419592*10^7s respectively Enter MRB1
to print 6532491 digits. The error from a 6, 000, 000 or more digit
calculation that used a different method is
0.*10^-6029992.

"Computation time" 72.526 days

"Absolute time" 185.491 days


# The MRB constant and its applications

Definition 1 CMRB is defined at https://en.wikipedia.org/wiki/MRB_constant .

From Wikipedia:

References
Plouffe, Simon. "mrburns". Retrieved 12 January 2015.
Burns, Marvin R. (23 January 1999). "RC". math2.org. Retrieved 5 May 2009.
Plouffe, Simon (20 November 1999). "Tables of Constants" (PDF). Laboratoire de combinatoire et d'informatique mathématique. Retrieved 5 May 2009.
Weisstein, Eric W. "MRB Constant". MathWorld.
Mathar, Richard J. (2009). "Numerical Evaluation of the Oscillatory Integral Over exp(iπx) x^*1/x) Between 1 and Infinity". arXiv:0912.3844 [math.CA].
Crandall, Richard. "Unified algorithms for polylogarithm, L-series, and zeta variants" (PDF). PSI Press. Archived from the original (PDF) on April 30, 2013. Retrieved 16 January 2015.
(sequence A037077 in the OEIS)
(sequence A160755 in the OEIS)
(sequence A173273 in the OEIS)
Fiorentini, Mauro. "MRB (costante)". bitman.name (in Italian). Retrieved 14 January 2015.
Finch, Steven R. (2003). Mathematical Constants. Cambridge, England: Cambridge University Press. p. 450. ISBN 0-521-81805-2.


The following equation that was shown in the Wikipedia definition shows how closely the MRB constant is related to root two.


In[1]:= N[Sum[Sqrt[2]^(1/n)* Sqrt[n]^(1/n) - ((Sqrt[2]^y*Sqrt[2]^x)^(1/Sqrt[2]^x))^Sqrt[2]^(-y)/.
x -> 2*Log2[a^2 + b^2] /.
y -> 2*Log2[-ai^2 - bi^2] /.
a -> 1 - (2*n)^(1/4) /.
b -> 2^(5/8)*Sqrt[n^(1/4)] /.
ai -> 1 - I*(2*n)^(1/4) /.
bi -> 2^(5/8)*Sqrt[I*n^(1/4)], {n, 1, Infinity}], 7]

Out[1]= 0.1878596 + 0.*10^-8 I


The complex roots and powers above are found to be well-defined because we get all either "integer" and "rational" the first of the following lists only, also by working from the bottom to the top of the above list of equations.

Code:

In[349]:= Table[
Expand[(Sqrt[2])^-y/(Sqrt[2])^x] //.
x -> 2 (Log[1 + Sqrt[2] Sqrt[n]]/Log[2]) /.
y -> 2 (Log[-1 + Sqrt[2] Sqrt[n]]/Log[2])]], {n, 1, 10}]

Out[349]= {Integer, Rational, Rational, Rational, Rational, Rational, \
Rational, Rational, Rational, Rational}

In[369]:= Table[
Expand[(Sqrt[2])^-y/(Sqrt[2])^x] //.
x -> 2 (Log[1 + Sqrt[2] Sqrt[n]]/Log[3]) /.
y -> 2 (Log[-1 + Sqrt[2] Sqrt[n]]/Log[2])]], {n, 1, 10}]

Out[369]= {Times, Rational, Times, Times, Times, Times, Times, Times, \
Times, Times}


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

From MathWorld:

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


How would we show that the any of the series in the above MathWorld definition are convergent, or even absolutely convergent?

For "a"k=k1/k, gven that the sequence is monotonically decreasing according to Steiner's Problem, next, we would like to show (5) is the alternating sum of a sequence that converges to 0 monotonically and use the Alternating series test to see that it is conditionally convergent

Here is a proof that 1 is the limit of "a" as k goes to infinity:

Here are many other proofs that 1 is the limit of "a" as k goes to infinity.

Thus, (k1/k-1) is a monotonically decreasing and bounded below by 0 sequence.

If we want an absolutely convergent series, we can use (4).

Sk which, since the sum of the absolute values of the summands is finite, the sum converges absolutely!

There is no closed-form for CMRB in the MathWorld definition; this could be due to the following: in Mathematical Constants,( Finch, S. R. Mathematical Constants, Cambridge, England: Cambridge University Press, p. 450), Steven Finch wrote that it is difficult to find an "exact formula" (closed-form solution) for it.

# Real-World, and beyond, Applications

## CMRB as a Growth Model

Its factor models the interest rate to multiply an investment k times in k periods, as well as "other growth and decay functions involving the more general expression , as in Plot 1A," because

r=(k^(1/k)-1);Animate[ListPlot[l=Accumulate[Table[(r+1)^n,{k,100}]], PlotStyle->Red,PlotRange->{0,150},PlotLegends->{"\!$$\*UnderscriptBox[\(\[Sum]$$, ]\)(r+1\!$$\*SuperscriptBox[\()$$, $$n$$]\)/.r->(\!$$\*SuperscriptBox[\(k$$, $$1/k$$]\)-1)/.n->"n},AxesOrigin->{0,0}],{n,0,5}]


Plot 1A

The discrete rates looks like the following.

r = (k^(1/k) - 1); me =
Animate[ListPlot[l = Table[(r + 1)^n, {k, 100}], PlotStyle -> Red,
PlotLegends -> {"(r+1)^n/.r->\!$$\*SuperscriptBox[\(k$$, \
$$1/k$$]\)=1/.n->", n}, AxesOrigin -> {0, 0},
PlotRange -> {0, 7}], {n, 1, 5}]


That factor models not only discretely compounded rates but continuous too, ie

By entering

Solve[P*E^(r*t) == P*(t^(1/t) - 1), r]


we see, for

gives an effect of continuous decay of Here Q1 means the first Quarter form 0 to -1.

The alternating sum of the principal of those continuous rates, i.e. P=(-1)t er t is the MRB constant (CMRB):

In[647]:= NSum[(-1)^t ( E^(r*t)) /. r -> Log[-1 + t^(1/t)]/t, {t, 1,
Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 30]

Out[647]= 0.18785964246206712024857897184


Its integral (MKB) is an analog to CMRB :

In[1]:= NIntegrate[(-1)^t (E^(r*t)) /. r -> Log[-1 + t^(1/t)]/t, {t,
1, Infinity I}, Method -> "Trapezoidal", WorkingPrecision -> 30] -
2 I/Pi

Out[1]= 0.0707760393115288035395280218303 -
0.6840003894379321291827444599927 I


So, integrating P yields about 1/2 greater of a total than summing:

In[663]:=
CMRB = NSum[(-1)^n ( Power[n, ( n)^-1] - 1), {n, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 30];

In[664]:=
MKB = Abs[
NIntegrate[(-1)^t ( E^(r*t)) /. r -> Log[-1 + t^(1/t)]/t, {t, 1,
Infinity I}, Method -> "Trapezoidal", WorkingPrecision -> 30] -
2 I/Pi];

In[667]:= MKB - CMRB

Out[667]= 0.49979272646562724956073343752


Next:

## CMRB from Geometric Series and Power Series

The MRB constant: is closely related to geometric series:

The inverse function of the "term" of the MRB constant, i.e. x^(1/x) within a certain domain is solved for in this link,

## ...

Consider the following about a slight generalization of that term.

CMRB can be written in geometric series form:

CMRB=

In[240]:= N[Quiet[(Sum[q^k, {x, 1, Infinity}] /.
k -> Log[-E^(I*Pi*x) + E^(x*(I*Pi + Log[x]/x^2))]/Log[q]) -
Sum[E^(I*Pi*x)*(-1 + x^(1/x)), {x, 1, Infinity}]]]

Out[240]= -4.163336342344337*^-16


Here too, with some shifting:

CMRB=

In[269]:= Quiet[
N[Sum[q^p - 1, {x, 1, Infinity}] -
Sum[E^(I*Pi*x)*(x^(1/x) - 1), {x, 1, Infinity}]] /.
p -> Log[(\!$$TraditionalForm\ \*SuperscriptBox[\((\(-1$$)\), $$x$$] $$(\ \*SuperscriptBox[\(q$$, $$k$$] - 1)\) + 1\))]/Log[q] /.
k -> Log[x]/(x*Log[q])]

Out[269]= 0.


It is also related to a power series of the form

, shifted by 1,

where we have

CMRB=

Sum[(-1)^x (q^k - 1) /. k -> Log[x]/(x Log[q]), {x, 1, Infinity}]


In[70]:= N[%]

Out[70]= 0.18786


Next

## The Geometry of the MRB constant

In 1837 Pierre Wantzel proved that an nth root of a given length cannot be constructed if n is not a power of 2 (as mentioned here in Wikipedia). However, the following is a little different.

For on November 21, 2010, I coined a multiversal analog to, Minkowski space that plots their values from constructions arising from a peculiar non-euclidean geometry, below, and fully in this vixra draft.

As in Diagram 2, we give each n-cube a hyperbolic volume (content) equal to its dimension, Geometrically, as in Diagram3, on the y,z-plane line up an edge of each n-cube. The numeric values displayed in the diagram are the partial sums of S[x_] = Sum[(-1)^n*n^(1/n), {n, 1, 2*u}] where u is an positive integer. Then M is the MRB constant.

Join[ Table[N[S[x]], {u, 1, 4}], {"..."}, {NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity}]}]


Out[421]= {0.414214, 0.386178, 0.354454, 0.330824, "...", 0.18786}

Next

## The publishing of CMRB.

Google Scholar results on MRB constant are here, which include the following.

Dr. Richard Crandall called the MRB constant a key fundamental constant

in this linked well-sourced and equally greatly cited Google Scholar promoted paper.

Dr. Richard J. Mathar wrote on the MRB constant here.

Xun Zhou, School of Water Resources and Environment, China University of Geosciences (Beijing), wrote the following in "on Some Series and Mathematic Constants Arising in Radioactive Decay" for the Journal of Mathematics Research, 2019.

A divergent infinite series may also lead to mathematical constants if its partial sum is bounded. The Marvin Ray Burns’ (MRB) constant is the upper bounded value of the partial sum of the divergent and alternating infinite series: -11/1+21/2-31/3+41/4-51/5+61/6-···=0.187859···(M. Chen, & S. Chen, 2016). Thus, construction of new infinite series has the possibility of leading to new mathematical constants.

CMRB is at the 38th most popular Wikipedia Mathematics page as of April 6, 2022. As of 20 April 2022, there are 6,486,890 articles in the English Wikipedia.

The geometry of the MRB constant's connection to string theory describing black holes results found in Ramanujan's modular equations, a connection to the Quantum Cosmological Constant, MRB constant integrals and relationships to other constants in string theory, in a relationship with the Ramanujan-Nardelli mock general formula, from Ramanujan's Mock Theta Functions to Black Hole Entropies and Symmetry, Supersymmetry, Golden Ratio, the MRB Constant and the linked integrals to it, applied to several equations of Geometric Measure Theory, to the Ramanujan’s equations and connections with some sectors of String Theory, new possible mathematical connections between the MRB constant and various sectors of Theoretical Physics and Cosmology, the study of some integrals concerning the MRB Constant and several equations of Geometric Measure Theory, analyzing new possible mathematical connections with some Cosmological parameters and sectors of String Theory, analyzing some Cosmological parameters and sectors of String Theory, and much more


Concerning his prolific writing on the MRB constant,    Michele Nardelli added the following.
In string theory, perturbation methods involve such a high degree of approximation that the theory is unable to identify which of the Calabi - Yau spaces are candidates for describing the universe. The consequence is that it does not describe a single universe, but something like 10^500 universes. In reality, admitting 10^500 different quantum voids would allow the only mechanism known at the moment to explain the present value of the cosmological constant following an idea by Steven Weinberg. Furthermore, a very large value of different voids is typical of any type of matter coupled to gravity and is also obtained when coupling the standard model. I believe that the multiverse is a "space of infinite dimensions" with infinite degrees of freedom and infinite possible potential wave functions that when they collapse, formalize a particle or a universe in a quantum state. The strings vibrating, like the strings of a musical instrument, emit frequencies that are not always precise numbers, indeed, very often they are decimal, irrational, and/or transcendent numbers. The MRB constant serves as a "regularizer" to obtain solutions as precise as possible and this in various sectors of string theory, black holes, and cosmology


In this physics.stackexchange question his concept of the dimensions in string theory and possible link with number theory is inquired about.

Many MRB constant papers by Michele Nardelli are found here in Google Scholar,which include previous versions of these.

Hello. Here are the links of my more comprehensive articles describing the various applications of the CMRB in various fields of theoretical physics and cosmology. Thanks always for your availability, see you soon.

# MeijerG Representation

From its integrated analog, I found a MeijerG representation for CMRB.

The search for it began with the following:

On 10/10/2021, I found the following proper definite integral that leads to almost identical proper integrals from 0 to 1 for CMRB and its integrated analog.

Here is a MeijerG function for the integrated analog. See (proof) of discovery.

f(n)=.

In[135]:=f[n_]:=MeijerG[{{},Table[1,{n+1}]},{Prepend[Table[0,n+1],-n+1],{}},-\[ImaginaryI]\[Pi]];
In[337]:=M2=NIntegrate[E^(I Pi x)(SuperscriptBox["x", FractionBox["1", "x"]]-1),
{x,1,Infinity I},WorkingPrecision->100]

Out[337]=0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723821-0.04738061707035078610720940650260367857315289969317363933196100090256586758807049779050462314770913485 \[ImaginaryI]


I wonder if there is one for the MRB constant sum (CMRB)?

According to "Primary Proof 1" and "Primary Proof 3" shown below along with the section prefixed by the phrase "So far I came up with," it can be proven that for G being the Wolfram MeijerG function

and f(n)=, and

g[x_] = (-1)^x (1 - (x + 1)^(1/(x + 1)));

In[52]:= (1/2)*
NIntegrate[(g[-t] - g[t])/(Sin[Pi*t]*Cos[Pi*t]*I + Sin[Pi*t]^2), {t,
0, I*Infinity}, WorkingPrecision -> 100,

Out[52]= 0.\
1170836031505383167089899122239912286901483986967757585888318959258587\
7430027817712246477316693025869 +
0.0473806170703507861072094065026036785731528996931736393319610009025\
6586758807049779050462314770913485 I

In[57]:= Re[
NIntegrate[
g[-t]/(Sin[Pi*t]*Cos[Pi*t]*I + Sin[Pi*t]^2), {t, 0, I*Infinity},
WorkingPrecision -> 100,

Out[57]= 0.\
1878596424620671202485179340542732300559030949001387861720046840894772\
315646602137032966544331074969


# MRB constant formulas and identities

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

## 3/25/2022

Formula (11) =

As Matheamatica says:

Assuming[Element[c, \[DoubleStruckCapitalZ]], FullSimplify[
E^(t*(r + I*Pi*(2*c + 1))) /. r -> Log[t^(1/t) - 1]/t]]


= E^(I (1 + 2 c) [Pi] t) (-1 + t^(1/t))

Where for all integers c, (1+2c) is odd leading to

Expanding the E^log term gives

which is ,

That is exactly (2) in the above-quoted MathWorld definition:

## 2/21/2022

Directly from the formula of 12/29/2021 below, In

u = (-1)^t; N[
NSum[(t^(1/t) - 1) u, {t, 1, Infinity }, WorkingPrecision -> 24,
Method -> "AlternatingSigns"], 15]


Out[276]= 0.187859642462067

In

v = (-1)^-t - (-1)^t; 2 I N[
NIntegrate[Im[(t^(1/t) - 1) v^-1], {t, 1, Infinity I},
WorkingPrecision -> 24], 15]


Out[278]= 0.187859642462067

Likewise,

Expanding the exponents,

This can be generalized to

Building upon that, we get a closed form for the inner integral in the following.

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

In[2]:= CMRB - {
Quiet[Im[NIntegrate[
Integrate[
E^(Log[t]/t + x)/(-E^((-I)*Pi*t + x) + E^(I*Pi*t + x)), {x,
I, -I}], {t, 1, Infinity I}, WorkingPrecision -> 200,
Method -> "Trapezoidal"]]];
Quiet[Im[NIntegrate[
Integrate[
Im[E^(Log[t]/t + x)/(-E^((-I)*Pi*t + x) + E^(I*Pi*t + x))], {x,
-t,  t }], {t, 1
, Infinity  I}, WorkingPrecision -> 2000,
Method -> "Trapezoidal"]]]}

Out[2]= {3.*10^-998, 3.*10^-998}


Which after a little analysis, can be shown convergent in the continuum limit at t → ∞ i.

## 12/29/2021

From "Primary Proof 1" worked below, it can be shown that

Mathematica knows that because

  m = N[NSum[-E^(I*Pi*t) + E^(I*Pi*t)*t^t^(-1), {t, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 27], 18];
Print[{m -
N[NIntegrate[
Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(I \[Pi] t) -
E^(-I \[Pi] t))] I, {t, 1, -Infinity I},
WorkingPrecision -> 20], 18],
m - N[NIntegrate[
Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(-I \[Pi] t) -
E^(I \[Pi] t))] I, {t, 1, Infinity I},
WorkingPrecision -> 20], 18],
m + 2 I*NIntegrate[
Im[(E^(I*Pi*t + Log[t]/t))/(-1 + E^((2*I)*Pi*t))], {t, 1,
Infinity I}, WorkingPrecision -> 20]}]


yields

  {0.*^-19,0.*^-19,0.*^-19}


Partial sums to an upper limit of (10^n i) give approximations for the MRB constant + the same approximation *10^-(n+1) i. Example:

-2 I*NIntegrate[
Im[(E^(I*Pi*t + Log[t]/t))/(-1 + E^((2*I)*Pi*t))], {t, 1, 10^7 I},
WorkingPrecision -> 20]


gives 0.18785602000738908694 + 1.878560200074*10^-8 I where CMRB ≈ 0.187856.

Notice it is special because if we integrate only the numerator, we have MKB=, which defines the "integrated analog of CMRB" (MKB) described by Richard Mathar in https://arxiv.org/abs/0912.3844. (He called it M1.)

Like how this:

NIntegrate[(E^(I*Pi*t + Log[t]/t)), {t, 1, Infinity I},
WorkingPrecision -> 20] - I/Pi


converges to

0.070776039311528802981 - 0.68400038943793212890 I.

(The upper limits " i infinity" and " infinity" produce the same result in this integral.)

## 11/14/2021

Here is a standard notation for the above mentioned

CMRB, .

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

Out[16]= -5.8542798212228838*10^-30

In[8]:= c1 =
Activate[Limit[(-1)^m/m! Derivative[m][DirichletEta][x] /. m -> 1,
x -> 1]]

Out[8]= 1/2 Log[2] (-2 EulerGamma + Log[2])

In[14]:= CMRB -
N[-(c1 + Sum[(-1)^m/m! Derivative[m][DirichletEta][m], {m, 2, 20}]),
30]

Out[14]= -6.*10^-30


## 11/01/2021

: The catalog now appears complete, and can all be proven through Primary Proof 1, and the one with the eta function, Primary Proof 2, both found below.

a ≠b

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, and next:

In[93]:= CMRB =
NSum[Cos[Pi n] (n^(1/n) - 1), {n, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 100]; Table[
CMRB - (1/2 +
NIntegrate[
Im[(t^(1/t) - t^(2 n))] (-Csc[\[Pi] t]), {t, 1, Infinity I},
WorkingPrecision -> 100, Method -> "Trapezoidal"]), {n, 1, 5}]

Out[93]= {-9.3472*10^-94, -9.3473*10^-94, -9.3474*10^-94, \
-9.3476*10^-94, -9.3477*10^-94}


CNT+F "The following is a way to compute the" for more evidence

For such n, converges to 1/2+0i.

(How I came across all of those and more example code follow in various replies.)

## 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 in this link 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}


Therefore, bringing

back to mind, we joyfully find,

In[1]:= n =
25.65665403510586285599072933607445153794770546058072048626118194900\
97321718621288009944007124739159792146480733342667100.;

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]]

During evaluation of In[1]:= {-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}

In[23]:= Quiet[
NIntegrate[
Im[g[(1 + I t)]/Sinh[\[Pi] t] -
g[(1 + I v)]/(Sinh[\[Pi] v] u^2)], {t, 1, Infinity},
WorkingPrecision -> 100]]

Out[23]= -3.\
9317890831820506378791034479406121284684487483182042179057328100219696\
20202464096600592983999731376*10^-55

In[21]:= Quiet[
NIntegrate[
Im[g[(1 + I t)]/Sinh[\[Pi] t] -
g[(1 - I v)]/(Sinh[-\[Pi] v] u^2)], {t, 1, Infinity},
WorkingPrecision -> 100]]

Out[21]= -3.\
9317890831820506378791034479406121284684487483182042179057381396998279\
83065832972052160228141179706*10^-55

In[25]:= Quiet[
NIntegrate[
Im[g[(1 + I t)]/Sinh[\[Pi] t] +
g[(1 + I v)]/(Sinh[-\[Pi] v] u^2)], {t, 1, Infinity},
WorkingPrecision -> 100]]

Out[25]= -3.\
9317890831820506378791034479406121284684487483182042179057328100219696\
20202464096600592983999731376*10^-55


## 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 in this link 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.

## 2020 and before:

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

CMRB =

Furthermore, as ,

according to user90369 at Stack Exchange, CMRB can be written as the sum of zeta derivatives similar to the eta derivatives discovered by Crandall. Information about η(j)(k) please see e.g. this link 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 eta(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 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.

Where the integral does not converge, but Mathematica can give it a value:

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 3.4 GHz Xeon processor with 64 GB 1666 MHz RAM.. 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.

63 Replies
Sort By:
Posted 8 years ago
 This is the second post in the MRB constant discussion, so right above this, if you can see the headerand the wordsReply | Flag at the same time,you might have to refresh the page to see the first message. The first message is crucial for understanding the MRB constant, as most of the facts are there. 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:
Posted 8 years ago

This is the third post in this discussion. If the messages in the first 2 posts aren't showing anything but ,

You need to refresh the page in order to view them.

The following email Crandall sent me before he died might be useful for anyone checking their results:

Posted 8 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.
Posted 8 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 8 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 8 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 8 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

## 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

## 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 4 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 ## 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: 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  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 4 years ago  nice system! Posted 4 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!!

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).

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:
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:
Posted 3 years ago

## 3/23/2019

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

Added to my cluster of

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 supercomputer, 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: 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.  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: 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: 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. Posted 2 years 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: Posted 2 years 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: Posted 2 years 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.} ...  Posted 2 years 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" Posted 2 years 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! Posted 2 years 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). 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. 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.. - 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  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. 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.nb https://www.wolframcloud.com/download/bmmmburns/Published/MRBSC 2.nb 1 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. ## Previously 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 3.4 GHz Xeon processor with 64 GB 1666 MHz RAM.. 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. ## 3/23/2019 Well, my mania struck again!!!!! I bought another computer that I can't afford. Added to my cluster of 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 an 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!!!!!!

Well, I rebuilt the MRB constant supercomputer stronger than ever. I will call it the MRB constant supercomputer 2. Here is how it looks:

![enter image description here][1111]

The MRB constant supercomputer 3 will have a combined 288 GB of 3200 to 4800 Mhz DCDR4 and DDR5 RAM!

Attachments:
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: .
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!
Posted 1 year 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.

Posted 1 year 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:
Posted 1 year 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:
Posted 1 year 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.
Posted 1 year 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!
Posted 1 year 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:
Posted 9 months ago
 As for why the following is true, I wrote a question here.That is an average of 30.0652174 digits per 22 i units. I got a good answer to my question:
Posted 7 months ago

# WOW!!!!

I discovered a non-trivial infinitude of proper integrals that all equal the MRB constant (CMRB):

Maybe a few more restrictions, like a≠b.

See cloud notebook.

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

In[239]:= g[x_] = x^(1/x); Table[w = (I (t - b))/(t - a);
CMRB - NIntegrate[
Re[g[(1 + w)] Csc[\[Pi] w]] (t - a)^-2*(b - a), {t, a, b},
WorkingPrecision -> 100], {a, 0, 5}, {b, a + 1, 6}]

Out[239]= {{-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94, \
-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94}, {-9.3472*10^-94, \
-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94}, \
{-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94}, \
{-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94}, {-9.3472*10^-94, \
-9.3472*10^-94}, {-9.3472*10^-94}}

In[240]:= g[x_] = x^(1/x); Table[w = (I (t - b))/(t - a);
CMRB - NIntegrate[
Re[g[(1 + w)] Csc[\[Pi] w]] (t - a)^-2*(b - a), {t, a, b},
WorkingPrecision -> 100], {a, 4/10, 5}, {b, a + 1, 6}]

Out[240]= {{-9.3472*10^-94, -9.3472*10^-94, -9.3472*10^-94, \
-9.3472*10^-94, -9.3472*10^-94}, {-9.3472*10^-94, -9.3472*10^-94, \
-9.3472*10^-94, -9.3472*10^-94}, {-9.3472*10^-94, -9.3472*10^-94, \
-9.3472*10^-94}, {-9.3472*10^-94, -9.3472*10^-94}, {-9.3472*10^-94}}

In[234]:= a = E; b = Pi;

In[254]:= a = E; b = Pi; g[x_] = x^(1/x); (w = (I (t - b))/(t - a);
Print[CMRB -
NIntegrate[
Re[g[(1 + w)] Csc[\[Pi] w]] (t - a)^-2*(b - a), {t, a, b},
WorkingPrecision -> 100]]); Clear[a, b]

During evaluation of In[254]:= -9.3472*10^-94

In[260]:= a = 1; b = I; g[x_] = x^(1/x); (w = (I (t - b))/(t - a);
Print[CMRB -
NIntegrate[
Re[g[(1 + w)] Csc[\[Pi] w]] (t - a)^-2*(b - a), {t, a, b},
WorkingPrecision -> 100]]); Clear[a, b]

During evaluation of In[260]:= -9.3472*10^-94+0.*10^-189 I

Posted 7 months ago

To add meaningful content about my second try at computing 6,500,000 digits, On 11 Sep 2021 at 14:15:27, I started the second try of computing 6,500,000 digits of the MRB constant. Here is the beginning of it:

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

Out[3]= {"KernelObject"[1, "local"], "KernelObject"[2, "local"],
"KernelObject"[3, "local"], "KernelObject"[4, "local"],
"KernelObject"[5, "local"], "KernelObject"[6, "local"],
"KernelObject"[7, "local"], "KernelObject"[8, "local"],
"KernelObject"[9, "local"], "KernelObject"[10, "local"]}

In[4]:= 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 digit \
calculation that used a different method is  "]; N[M6M - MRB1, 20]

Start time is Sat 11 Sep 2021 14:15:27.

Iterations required: 8622898

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

Will stop at 8624128 iterations to ensure precsion of around 6532499 decimal places.

As of  Sat 11 Sep 2021 16:12:51 there were 2048 iterations done in 7043.8 seconds. That is 0.29075 iterations/s. 0.02374733% complete. It should take 343.254 days or 2.966*10^7s, and finish Sat 20 Aug 2022 20:21:49.

As of  Sat 11 Sep 2021 17:12:08 there were 4096 iterations done in 10601. seconds. That is 0.38637 iterations/s. 0.04749466% complete. It should take 258.305 days or 2.232*10^7s, and finish Fri 27 May 2022 21:33:57.

As of  Sat 11 Sep 2021 18:11:36 there were 6144 iterations done in 14169. seconds. That is 0.43362 iterations/s. 0.07124199% complete. It should take 230.158 days or 1.989*10^7s, and finish Fri 29 Apr 2022 18:03:12.

As of  Sat 11 Sep 2021 19:11:08 there were 8192 iterations done in 17742. seconds. That is 0.46174 iterations/s. 0.09498931% complete. It should take 216.143 days or 1.867*10^7s, and finish Fri 15 Apr 2022 17:41:28.

As of  Sat 11 Sep 2021 20:11:06 there were 10240 iterations done in 21339. seconds. That is 0.47988 iterations/s. 0.1187366% complete. It should take 207.975 days or 1.797*10^7s, and finish Thu 7 Apr 2022 13:38:45.

As of  Sat 11 Sep 2021 21:10:48 there were 12288 iterations done in 24922. seconds. That is 0.49307 iterations/s. 0.1424840% complete. It should take 202.410 days or 1.749*10^7s, and finish Sat 2 Apr 2022 00:06:22.

As of  Sat 11 Sep 2021 22:10:33 there were 14336 iterations done in 28506. seconds. That is 0.50292 iterations/s. 0.1662313% complete. It should take 198.447 days or 1.715*10^7s, and finish Tue 29 Mar 2022 00:59:01.

As of  Sat 11 Sep 2021 23:10:20 there were 16384 iterations done in 32094. seconds. That is 0.51051 iterations/s. 0.1899786% complete. It should take 195.496 days or 1.689*10^7s, and finish Sat 26 Mar 2022 02:10:06.

As of  Sun 12 Sep 2021 00:10:16 there were 18432 iterations done in 35689. seconds. That is 0.51646 iterations/s. 0.2137260% complete. It should take 193.244 days or 1.670*10^7s, and finish Wed 23 Mar 2022 20:06:35.

As of  Sun 12 Sep 2021 01:10:13 there were 20480 iterations done in 39286. seconds. That is 0.52130 iterations/s. 0.2374733% complete. It should take 191.448 days or 1.654*10^7s, and finish Tue 22 Mar 2022 00:59:55.

As of  Sun 12 Sep 2021 02:10:21 there were 22528 iterations done in 42895. seconds. That is 0.52519 iterations/s. 0.2612206% complete. It should take 190.029 days or 1.642*10^7s, and finish Sun 20 Mar 2022 14:57:42.

As of  Sun 12 Sep 2021 03:10:12 there were 24576 iterations done in 46485. seconds. That is 0.52868 iterations/s. 0.2849679% complete. It should take 188.775 days or 1.631*10^7s, and finish Sat 19 Mar 2022 08:51:24.

As of  Sun 12 Sep 2021 04:10:16 there were 26624 iterations done in 50090. seconds. That is 0.53153 iterations/s. 0.3087153% complete. It should take 187.764 days or 1.622*10^7s, and finish Fri 18 Mar 2022 08:36:14.

As of  Sun 12 Sep 2021 05:10:21 there were 28672 iterations done in 53695. seconds. That is 0.53398 iterations/s. 0.3324626% complete. It should take 186.901 days or 1.615*10^7s, and finish Thu 17 Mar 2022 11:53:02.

As of  Sun 12 Sep 2021 06:10:39 there were 30720 iterations done in 57312. seconds. That is 0.53601 iterations/s. 0.3562099% complete. It should take 186.194 days or 1.609*10^7s, and finish Wed 16 Mar 2022 18:55:17.

As of  Sun 12 Sep 2021 07:10:34 there were 32768 iterations done in 60908. seconds. That is 0.53799 iterations/s. 0.3799573% complete. It should take 185.507 days or 1.603*10^7s, and finish Wed 16 Mar 2022 02:26:09.

As of  Sun 12 Sep 2021 08:10:43 there were 34816 iterations done in 64517. seconds. That is 0.53964 iterations/s. 0.4037046% complete. It should take 184.940 days or 1.598*10^7s, and finish Tue 15 Mar 2022 12:49:33.

As of  Sun 12 Sep 2021 09:10:53 there were 36864 iterations done in 68126. seconds. That is 0.54111 iterations/s. 0.4274519% complete. It should take 184.439 days or 1.594*10^7s, and finish Tue 15 Mar 2022 00:47:44.

As of  Sun 12 Sep 2021 10:11:13 there were 38912 iterations done in 71746. seconds. That is 0.54236 iterations/s. 0.4511992% complete. It should take 184.015 days or 1.590*10^7s, and finish Mon 14 Mar 2022 14:37:07.

As of  Sun 12 Sep 2021 11:11:23 there were 40960 iterations done in 75356. seconds. That is 0.54355 iterations/s. 0.4749466% complete. It should take 183.611 days or 1.586*10^7s, and finish Mon 14 Mar 2022 04:55:05.

As of  Sun 12 Sep 2021 12:11:44 there were 43008 iterations done in 78977. seconds. That is 0.54456 iterations/s. 0.4986939% complete. It should take 183.270 days or 1.583*10^7s, and finish Sun 13 Mar 2022 20:43:58.

As of  Sun 12 Sep 2021 13:12:23 there were 45056 iterations done in 82617. seconds. That is 0.54536 iterations/s. 0.5224412% complete. It should take 183.001 days or 1.581*10^7s, and finish Sun 13 Mar 2022 14:17:02.


... (the 350208 iterations result [using V 11.3, which is the fastest version thus far when using this program.])

As of  Sat 18 Sep 2021 20:46:12 there were 350208 iterations done in 6.2825*10^5 seconds. That is 0.55744 iterations/s. 4.060793% complete. It should take 179.037 days or 1.547*10^7s, and finish Wed 9 Mar 2022 15:08:44.


Comparing that 350208 iterations result using 10 cores with the previous attempt using 8 cores and V 12.0:

As of  Wed 25 Nov 2020 01:51:56 there were 350208 iterations done in 7.2434*10^5 seconds. That is 0.48349 iterations/s. 4.060793% complete. It should take 206.421 days or 1.783*10^7s, and finish Fri 11 Jun 2021 02:46:01.


It should finish 206.421-179.037 =27.384 days quicker or in 179.037/206.421*100=86.734% of the time. That is 100-86.734=13.27% faster.

Here a recent update:

As of  Thu 23 Sep 2021 18:41:31 there were 581632 iterations done in 1.0528*10^6 seconds. That is 0.55248 iterations/s. 6.744241% complete. It should take 180.643 days or 1.561*10^7s, and finish Fri 11 Mar 2022 05:42:03.


A few days later,

As of  Mon 27 Sep 2021 01:47:53 there were 735232 iterations done in 1.3375*10^6 seconds. That is 0.54969 iterations/s. 8.525291% complete. It should take 181.562 days or 1.569*10^7s, and finish Sat 12 Mar 2022 03:44:11.


The 6,500,000 digit computation is more than 10% complete:

As of  Thu 30 Sep 2021 19:18:23 there were 907264 iterations done in 1.6598*10^6 seconds. That is 0.54662 iterations/s. 10.52007% complete. It should take 182.581 days or 1.577*10^7s, and finish Sun 13 Mar 2022 04:11:53.


The MRB constant supercomputer just said,

As of  Fri 8 Oct 2021 18:43:26 there were 1275904 iterations done in   2.3489*10^6 seconds. That is 0.54320 iterations/s. 14.79459% complete. It should take  183.731 days or 1.587*10^7s, and finish Mon  14 Mar 2022 07:47:59.


The second try at 6,500,000 digits of the MRB constant just reached 20% complete.

      As of  Mon 18 Oct 2021 21:39:10 there were 1744896 iterations done in 3.2234*10^6 seconds. That is 0.54132 iterations/s. 20.23272% complete. It should take         184.369 days or 1.593*10^7s, and finish Mon 14 Mar 2022 23:06:28.

As of  Fri 5 Nov 2021 13:34:35 there were 2562048 iterations done in  4.7495*10^6 seconds. That is 0.53943 iterations/s. 29.70791% complete. It should take 185.014 days or 1.599*10^7s, and finish Tue  15 Mar 2022 14:35:33.

As of  Thu 11 Nov 2021 09:53:25 there were 2832384 iterations done in  5.2547*10^6 seconds. That is 0.53902 iterations/s. 32.84256% complete. It should take 185.154 days or 1.600*10^7s, and finish on  Tue15 Mar 2022 17:57:27.

As of  Thu 18 Nov 2021 20:16:05 there were 3176448 iterations done in  5.8968*10^6 seconds. That is 0.53867 iterations/s. 36.83211% complete. It should take 185.275 days or 1.601*10^7s, and finish Tue  15 Mar 2022 20:51:33.

As of  Tue 23 Nov 2021 12:14:29 there were 3393536 iterations done in   6.2999*10^6 seconds. That is 0.53866 iterations/s. 39.34932% complete. It should take 185.278 days or 1.601*10^7s, and finish Tue15   Mar 2022 20:55:36.

As of  Fri 26 Nov 2021 18:29:56 there were 3545088 iterations done in  6.5817*10^6 seconds. That is 0.53863 iterations/s. 41.10663% complete. It should take   185.289 days or 1.601*10^7s, and finish Tue15  Mar 2022 21:10:54.

As of  Tue 30 Nov 2021 17:50:37 there were 3729408 iterations done in 6.9249*10^6 seconds. That is 0.53855 iterations/s. 43.24389% complete. It should take  185.316 days or 1.601*10^7s, and finish Tue 15 Mar 2022 21:50:59.

As of  Fri 10 Dec 2021 22:07:56 there were 4200448 iterations done in 7.8043*10^6 seconds. That is 0.53822 iterations/s. 48.70577% complete. It should take  185.430 days or 1.602*10^7s, and finish Wed  16 Mar 2022 00:35:01.


The 6,500,000 is more than 50% complete!!

     As of  Mon 13 Dec 2021 09:15:08 there were 4315136 iterations done in 8.0172*10^6 seconds. That is 0.53824 iterations/s. 50.03562% complete. It should take  185.424 days or 1.602*10^7s, and finish Wed16 Mar 202200:26:28.

As of  Fri 24 Dec 2021 01:02:38 there were 4808704 iterations done in 8.9380*10^6 seconds. That is 0.53800 iterations/s. 55.75873% complete. It should take 185.504 days or 1.603*10^7s, and finish Wed  16 Mar 2022 02:21:14.

...


Stay tuned, I will add the next several 6,500,000 digit computation updates in this reply.

## Last update for 2021

 As of  Fri 31 Dec 2021 21:19:50 there were 5171200 iterations done in
9.6159*10^6 seconds. That is 0.53778 iterations/s. 59.96200% complete. It should take 185.582
days or 1.603*10^7s, and finish Wed 16 Mar 2022  04:13:54


## 2022 results

As of  Sun 9 Jan 2022 14:06:53 there were 5574656 iterations done in 1.0367*10^7 seconds. That is 0.53771 iterations/s. 64.64023% complete. It should take 185.607 days or 1.604*10^7s, and finish Wed 16 Mar 2022 04:49:52.

As of  Thu 13 Jan 2022 16:22:21 there were 5769216 iterations done in 1.0721*10^7 seconds. That is 0.53811 iterations/s. 66.89622% complete. It should take 185.467 days or 1.602*10^7s, and finish Wed 16 Mar 2022 01:27:56.

As of  Sun 16 Jan 2022 17:26:12 there were 5914624 iterations done in 1.0984*10^7 seconds. That is 0.53846 iterations/s. 68.58228% complete. It should take 185.346 days or 1.601*10^7s, and finish Tue 15 Mar 2022 22:33:18.

As of  Thu 20 Jan 2022 07:33:07 there were 6082560 iterations done in 1.1294*10^7 seconds. That is 0.53855 iterations/s. 70.52957% complete. It should take 185.315 days or 1.601*10^7s, and finish Tue 15 Mar 2022 21:49:15.

As of  Sun 23 Jan 2022 16:03:35 there were 6238208 iterations done in 1.1584*10^7 seconds. That is 0.53852 iterations/s. 72.33436% complete. It should take 185.328 days or 1.601*10^7s, and finish Tue 15 Mar 2022 22:08:03.

As of  Sun 30 Jan 2022 23:10:01 there were 6578176 iterations done in 1.2214*10^7 seconds. That is 0.53856 iterations/s. 76.27642% complete. It should take 185.314 days or 1.601*10^7s, and finish Tue 15 Mar 2022 21:47:57.

As of  Fri 4 Feb 2022 23:41:41 there were 6811648 iterations done in 1.2648*10^7 seconds. That is 0.53854 iterations/s. 78.98361% complete. It should take 185.320 days or 1.601*10^7s, and finish Tue 15 Mar 2022 21:56:04.

As of  Sat 12 Feb 2022 20:13:25 there were 7176192 iterations done in 1.3327*10^7 seconds. That is 0.53847 iterations/s. 83.21064% complete. It should take 185.345 days or 1.601*10^7s, and finish Tue 15 Mar 2022 22:31:57.

As of  Wed 23 Feb 2022 01:37:22 there were 7647232 iterations done in 1.4211*10^7 seconds. That is 0.53814 iterations/s. 88.67252% complete. It should take 185.458 days or 1.602*10^7s, and finish Wed 16 Mar 2022 01:14:39.

As of  Mon 28 Feb 2022 05:28:10 there were 7884800 iterations done in 1.4656*10^7 seconds. That is 0.53798 iterations/s. 91.42721% complete. It should take 185.513 days or 1.603*10^7s, and finish Wed 16 Mar 2022 02:34:35.

As of  Sat 5 Mar 2022 19:48:58 there were 8142848 iterations done in 1.5140*10^7 seconds. That is 0.53784 iterations/s. 94.41938% complete. It should take 185.562 days or 1.603*10^7s, and finish Wed 16 Mar 2022 03:44:56.

As of  Thu 10 Mar 2022 17:11:21 there were 8368128 iterations done in 1.5563*10^7 seconds. That is 0.53771 iterations/s. 97.03158% complete. It should take 185.606 days or 1.604*10^7s, and finish Wed 16 Mar 2022 04:48:07.

As of  Sat 12 Mar 2022 21:00:40 there were 8470528 iterations done in 1.5749*10^7 seconds. That is 0.53784 iterations/s. 98.21895% complete. It should take 185.560 days or 1.603*10^7s, and finish Wed 16 Mar 2022 03:42:19.


Probably my last update:

As of  Mon 14 Mar 2022 23:47:25 there were 8570880 iterations done in 1.5932*10^7 seconds. That is 0.53797 iterations/s. 99.38257% complete. It should take 185.516 days or 1.603*10^7s, and finish Wed 16 Mar 2022 02:38:58.


**

## Less than 26 hours until completion!

**

Posted 6 months ago
 While waiting for results on the 2nd try of calculating 6,500,000 digits of the MRB constant (CMRB), I thought I would compare the rate of convergence of 3 major different forms of it. They are listed from slowest to fastest
Posted 2 months ago
 Time for a quick memorial:This discussion began sometime around 2/21/2013. "This MRB records posting reached a milestone of over 120,000 views on 3/31/2020, around 4:00 am.""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!""7:00 pm 10/8/2021 it had 520,000 views!"1:40 am 3/2/2022 600,000 views8:25 pm 5/4/2022 650,000 views In the last 7 months, this discussion has had as many visitors as it did in its first 7 years!
Posted 2 months ago

# I calculated 6,500,000 digits of the MRB constant!!

The MRB constant supercomputer said,

Finished on Wed 16 Mar 2022 02 : 02 : 10. Processor and actual time were 6.2662810^6 and 1.6026403541959210^7 s.respectively Enter MRB1 to print 6532491 digits. The error from a 6, 000, 000 or more digit calculation that used a different method is 0.*10^-6029992

"Processor time" 72.526 days

"Actual time" 185.491 days

For the digits see the attached 6p5millionMRB.nb. For the documentation of the computation see 2nd 6p5 million.nb.

Attachments:
Posted 1 month ago

# Programs to compute the integrated analog

## The efficient programs

Wed 29 Jul 2015 11:40:10

From an initial accuracy of only 7 digits,

0.0707760393115288035395280218302820013719.163032309866352 -
0.6840003894379321291827444599926611267120.1482024033675 I - \
(NIntegrate[(-1)^t (t^(1/t) - 1), {t, 1, Infinity},
WorkingPrecision -> 20] - 2 I/Pi)


we have the first efficient program to compute the integrated analog (MKB) of the MRB constant, which is good for 35,000 digits.

Block[{$MaxExtraPrecision = 200}, prec = 4000; f[x_] = x^(1/x); ClearAll[a, b, h]; Print[DateString[]]; Print[T0 = SessionTime[]]; If[prec > 35000, d = Ceiling[0.002 prec], d = Ceiling[0.264086 + 0.00143657 prec]]; h[n_] := Sum[StirlingS1[n, k]* Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}]; h[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}]; sinplus1 := NIntegrate[ Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, WorkingPrecision -> prec*(105/100), PrecisionGoal -> prec*(105/100)]; cosplus1 := NIntegrate[ Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, WorkingPrecision -> prec*(105/100), PrecisionGoal -> prec*(105/100)]; middle := Print[SessionTime[] - T0, " seconds"]; end := Module[{}, Print[SessionTime[] - T0, " seconds"]; Print[c = Abs[a + b]]; Print[DateString[]]]; If[Mod[d, 4] == 0, Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]]; middle; Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]]; end]; If[Mod[d, 4] == 1, Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]]; middle; Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end]; If[Mod[d, 4] == 2, Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]]; middle; Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]]; end]; If[Mod[d, 4] == 3, Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]]; middle; Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]]; end];]  May 2018 I got substantial improvement in calculating the digits of MKB by using V11.3 in May 2018, my new computer (processor Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz, 3601 MHz, 4 Core(s), 8 Logical Processor(s) with 16 GB 2400 MH DDR4 RAM): Digits Seconds 2000 67.5503022 3000 217.096312 4000 514.48334 5000 1005.936397 10000 8327.18526 20000 71000  They are found in the attached 2018 quad MKB.nb. They are twice as fast,(or more) as my old records with the same program using Mathematica 10.2 in July 2015 on my old big computer (a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of 1066 MHz DDR3 RAM): digits seconds 2000 256.3853590 3000 794.4361122 4000 1633.5822870 5000 2858.9390025 10000 17678.7446323 20000 121431.1895170 40000 I got error msg  May 2021 After finding the following rapidly converging integral for MKB, (See Primary Proof 3 in the first post.) I finally computed 200,000 digits of MKB (0.070776 - 0.684 I...) Started ‎Saturday, ‎May ‎15, ‎2021, ‏‎10: 54: 17 AM, and finished at 9:23:50 am EDT | Friday, August 20, 2021, for a total of 8.37539*10^6 seconds or 96 days 22 hours 29 minutes 50 seconds. The full computation, verification to 100,000 digits, and hyperlinks to various digits are found below at 200k MKB A.nb. The code was g[x_] = x^(1/x); u := (t/(1 - t)); Timing[ MKB1 = (-I Quiet[ NIntegrate[(g[(1 + u I)])/(Exp[Pi u] (1 - t)^2), {t, 0, 1}, WorkingPrecision -> 200000, Method -> "DoubleExponential", MaxRecursion -> 17]] - I/Pi)]  After finding the above more rapidly converging integral for MKB, In only 80.5 days, 189,330 real digits and 166,700 imaginary were confirmed to be correct by the following different formula. as Seen at https://www.wolframcloud.com/obj/bmmmburns/Published/2nd%20200k%20MRB.nb All digits at https://www.wolframcloud.com/obj/bmmmburns/Published/200K%20confirmed%20MKB.nb (Recommended to open in desktop Mathematica.) N[(Timing[ FM2200K - (NIntegrate[(Exp[Log[t]/t - Pi t/I]), {t, 1, Infinity I}, WorkingPrecision -> 200000, Method -> "Trapezoidal", MaxRecursion -> 17] - I/Pi)]), 20]  I've learned more about what MaxRecusion is required for 250,000 digits to be verified from the two different formulas, and they are being computed as I write. It will probably take over 100 days. ## Laurent series for the analog I've not perfected the method, but here is how to compute the integrated analog of the MRB constant from series. $f = (-1)^z (z^(1/z) - 1); MKB =
NIntegrate[$f, {z, 1, Infinity I}, WorkingPrecision -> 500]; Table[s[x_] = Series[$f, {z, n, x}] // Normal;
Timing[Table[
MKB - Quiet[
NIntegrate[s[x] /. z -> n, {n, 1, Infinity I},
WorkingPrecision -> p, Method -> "Trapezoidal",
MaxRecursion -> Ceiling[Log2[p/2]]]], {p, 100, 100 x,
100}]], {x, 1, 10}] // TableForm


Table[Short[s[n]], {n, 1, 5}] // TableForm

Attachments:
Posted 1 month ago

## How about a cool 7 million digits?

I'm adding a new node that runs 16 Mathematica kernels to the MRB constant supercomputer! With the additional node installed, I will name it the MRB constant supercomputer3

System Configuration: Chassis Model: Digital Storm Lynx Exterior

Finish: - Standard Factory Finish Trim Accents: - Standard Factory  Finish

Processor: Intel Core i9-12900K (5.2 GHz Turbo) (24-Thread)  (16-Core) 3.2 GHz (Alder Lake)

Motherboard: ASUS Prime Z690-A (Intel  Z690 Chipset) (Up to 3x PCI-E Devices) (No SLI) (DDR5)

System Memory: 64GB DDR5 4800MHz Digital Storm Performance Series

Power Supply: 850WDigital Storm Performance Series (Modular) (80 Plus Gold)

Storage Set 1: 1x SSD M.2 (1TB Samsung 970 EVO PLUS) (NVM Express)

Storage Set 2: 1x Storage (4TB Western Digital / Seagate - Ultrastar Data Center / IronWolf)

Storage Set 3: 1x Storage (4TB Western Digital / Seagate - Ultrastar Data Center / IronWolf)

RAID Config: RAID 0: Striping: Performance.  But No Data Fault Tolerance (Requires 2 Identical HDDs)

Graphics Card(s): 1x  GeForce GTX 1650 4GB Sound Card: Integrated Motherboard Audio

Cooling: H20: Stage 3: Digital Storm Vortex  Liquid CPU Cooler (Triple Fan) (Fully Sealed + No Maintenance)

Premium Cable Management (Strategically Routed & Organized for Airflow) Chassis Fans: Digital Storm

Performance Series (RGB Fans) Internal Lighting: Remote Controlled

Advanced LED Lighting System (Multiple RGB Color Modes) \

CPU Boost: Stage 2: Overclock CPU - Up to 5.1GHz on All CPU Cores Graphics:

Disable and tweak all of  the non-crucial services on the operating system

Operating System Microsoft Windows 11 Home (64-Bit) Recovery Tools: USB Drive - Windows


Here is the code I plan to use on it to check the 7 million digits computed next.

Print["Start time is ", ds = DateString[], "."];
prec = 7000000;
(**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 = 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}]];
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 6,500,000 or more digit
calculation that used a different method is  "]; N[MRB - MRB1, 20]


. .

.

.

.

From the MRB constant supercomputer, using only one node:

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

Out[5]= {"KernelObject"[1, "local"], "KernelObject"[2, "local"],
"KernelObject"[3, "local"], "KernelObject"[4, "local"],
"KernelObject"[5, "local"], "KernelObject"[6, "local"],
"KernelObject"[7, "local"], "KernelObject"[8, "local"],
"KernelObject"[9, "local"], "KernelObject"[10, "local"]}

In[6]:= Print["Start time is ", ds = DateString[], "."];
prec = 7000000;
(**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`