This is the second half of the main post.

Gemini helped to rewrite this half.

§2

Central Claim:

The MRB constant (C) can be expressed as:

$$ C = \sum_{n=2}^{\infty} (-1)^n (n^{1/n} - 1)$$

$$ = -\sum_{m=1}^{\infty} \frac{(-1)^m}{m!} \eta^{(m)}(m)$$

where $(\eta(s)) $is the Dirichlet eta function and $(\eta^{(m)}(m)) $ represents its $m^{th}$ derivative evaluated at $(s=m)$.

Proof Strategy:

Manipulatie an infinite series representation of the MRB constant. The core idea is:

1. Series Representation of MRB Constant: Start with a known series representation of the MRB constant.
2. Taylor Series Expansion: Expand a key term within the series using a Taylor series.
3. Rearrangement and Cancellation: Rearrange the resulting terms and observe that certain terms cancel out.
4. Relationship with Eta Function: Recognize that the remaining terms can be expressed in terms of the Dirichlet eta function and its derivatives.

Formal Proof:

1. Series Representation: We begin with the following representation of the MRB constant (C):

$$C = \sum_{n=2}^{\infty} (-1)^n (n^{1/n} - 1)$$

1. Taylor Series Expansion: The term (n^{1/n}) can be expressed using the Taylor series for (e^x):

$$n^{1/n} = e^{\frac{\log n}{n}} = 1 + \frac{\log n}{n} + \frac{\log^2 n}{2! n^2} + \frac{\log^3 n}{3! n^3} + \dotsb $$

1. Substitute and Rearrange: Substitute this expansion into the MRB series and rearrange:

$ \begin{align*} C &= \sum_{n=2}^{\infty} (-1)^n \left( \frac{\log n}{n} + \frac{\log^2 n}{2! n^2} + \frac{\log^3 n}{3! n^3} + \dotsb \right) \\ &= \sum_{m=1}^{\infty} \frac{1}{m!} \sum_{n=2}^{\infty} (-1)^n \frac{\log^m n}{n^m} \end{align*}$

1. Dirichlet Eta Function: Recognize the inner sum as the Dirichlet eta function and its derivatives:

$$\eta^{(m)}(s) = \frac{d^m}{ds^m} \left( \sum_{n=1}^{\infty} \frac{(-1)^{n-1}}{n^s} \right) = (-1)^{m+1} \sum_{n=1}^{\infty} (-1)^n \frac{\log^m n}{n^s}$$

Therefore,

$$C = -\sum_{m=1}^{\infty} \frac{(-1)^m}{m!} \eta^{(m)}(m)$$

This completes the proof.

Important Note: The manipulations in this proof are valid due to the absolute convergence of the series involved. This transformation leads to a "well-behaved, absolutely convergent series" which is important for the numerical computation of the MRB constant.

Here is how the speedily convergent sum (in midnight blue (Look closely!)) compares with the prototype (in yellow) to the precise value of the MRB constant (CMRB) (in red).

Concerning the sum prototype for CMRB

§3. Is the series convergent?

Proof of its convergence by Leibniz's criterion is shown next.

PROOF

We will prove the convergence of this series using the Alternating Series Test.

Alternating Series Test

An alternating series of the form
∑ (-1)^n * b_n where b_n > 0 for all n, converges if the following two conditions are met:

1. Decreasing: The sequence b_n is decreasing.
2. Limit Zero: lim (n -> ∞) b_n = 0

Applying the Test

Let's analyze our series:

∑ (-1)^n * (n^(1/n) - 1)

1. Decreasing:

We need to show that the sequence b_n = n^(1/n) - 1 is decreasing.

• Consider the function f(x) = x^(1/x) - 1.
• Take the derivative: f'(x) = x^(1/x) * (1 - ln(x)) / x^2.
• For x > e, f'(x) is negative, meaning f(x) (and thus b_n) is decreasing.

2 Limit Zero:

We need to show lim (n -> ∞) (n^(1/n) - 1) = 0.

• Recall that lim (n -> ∞) n^(1/n) = 1 (this can be proven using L'Hopital's rule or other methods).
• Therefore, lim (n -> ∞) (n^(1/n) - 1) = 1 - 1 = 0.

Conclusion

Since both conditions of the Alternating Series Test are satisfied, we conclude that the series:

∑ (-1)^n * (n^(1/n) - 1)

is convergent.

Important Note: The Alternating Series Test only tells us the series converges. It doesn't tell us the value it converges to.

§4 Next, ask and observe,

Theorem: The series

$\sum_{n=1}^{\infty} (-1)^n (-z_0 + n^{1/n}) $

converges if and only if (z_0 = 1).

Proof:

(Necessity - If the series converges, then (z_0 = 1)):

1. Divergence Test: Recall the Divergence Test from calculus: If the series (\sum an) converges, then (\lim{n\to\infty} a_n = 0).
2. Apply to Our Series: In our case, the terms of the series are
   $$a_n = (-1)^n (-z_0 + n^{1/n}).$$
3. Limit of the Terms: We know $(\lim_{n\to\infty} n^{1/n} = 1).$ Therefore, for the limit of (a_n) to be zero, the constant term $(-z_0)$ must cancel out the 1. This implies $(-z_0=1)$

(Sufficiency - If (z_0 = 1), then the series converges):

1. Alternating Series Test: If we set (z_0 = 1), our series becomes $$\sum_{n=1}^{\infty} (-1)^n (n^{1/n} - 1).$$ This is an alternating series. To apply the Alternating Series Test, we need to show:

• Decreasing Terms: The sequence $((n^{1/n} - 1))$ is decreasing for $(n \ge 3).$ (This can be shown using calculus.)
• Limit to Zero: We already know $(\lim_{n\to\infty} (n^{1/n} - 1) = 0).$

1. Conclusion of Alternating Series Test: Since both conditions of the Alternating Series Test are met, the series converges when $(z_0 = 1).$

Therefore, the series converges if and only if $(z_0 = 1).$

Additional Notes:

• Conditional Convergence: The series converges conditionally when $(z_0 = 1).$, as the absolute values of the terms do not form a convergent series.
• The MRB Constant: The case $(z_0 = 1).$ is precisely the definition of the MRB constant. This theorem shows that any slight deviation from $(z_0 = 1).$ leads to a divergent series.

§5. Is that series, absolutely convergent?

The following criterion works remarkably well in determining its lack of absolute convergence.

Proposition: The series
$$\sum_{n \ge 1} (-1)^n (n^{1/n} - 1)$$ is not absolutely convergent.

Proof:

To prove this, we need to show that the series of absolute values, $$\sum_{n \ge 1} |n^{1/n} - 1|$$ diverges.

1. Establish a Bound:

We will show that for sufficiently large (n), the following inequality holds: $$n^{1/n} - 1 > \frac{1}{n}$$

1. Manipulate the Inequality:

• Start with the known inequality (for (n > 1)): $$n > e > \left(1 + \frac{1}{n}\right)^n$$

• Take the (n)-th root of both sides (preserving the inequality since all terms are positive): $$n^{1/n} > 1 + \frac{1}{n}$$

• Rearrange to get the desired inequality: $$n^{1/n} - 1 > \frac{1}{n}$$

1. Comparison with Harmonic Series:

• We know that the Harmonic Series, $(\sum_{n \ge 1} \frac{1}{n})$, diverges.

• Since we've shown that $( |n^{1/n} - 1| > \frac{1}{n} $) for sufficiently large (n), by the Comparison Test, the series of absolute values: $$\sum_{n \ge 1} |n^{1/n} - 1|$$ also diverges.

1. Conclusion:

Therefore, the original series $$\sum_{n \ge 1} (-1)^n (n^{1/n} - 1)$$ is not absolutely convergent.

Key Points:

• Absolute Convergence: A series is absolutely convergent if the series of its absolute values converges.
• Comparison Test: If $(0 \le a_n \le b_n)$ for all (n), and $(\sum b_n)$ diverges, then $(\sum a_n)$ also diverges.
• Harmonic Series: The Harmonic Series is a well-known example of a divergent series.

Let me know if you have any other questions! §6 As for efficiency, this discussion presents several series that converge much faster for CMRB. Here are a few of their convergence rates. The following expressions show the sum followed by the closeness to zero of their result after a certain number of partial summations.

[This section is being condensed.]

For how more efficient forms compare,

"the rate of convergence" of 3 major forms.

§7. This discussion is an attempt by this amateur to share my discoveries with the greatest audience possible.

Amateurs have made a few significant discoveries, as discussed in here. This amateur have tried my best to prove my discoveries and have often asked for help. Great thanks to all of those who offered a hand!

As I shared more of my findings regarding the MRB constant, I wanted to ensure I acknowledged any potential prior work. While my research suggests the unique approach I've taken is original, I'm well aware that mathematics has a long and rich history. It's entirely possible someone else has pondered the same ideas, perhaps in a different context.

If that's the case, I offer my sincere apologies for any oversight in attribution. The last thing the mathematical community needs is another priority dispute. I'm simply excited by the potential this constant seems to hold.

I firmly believe that the connections with the Dirichlet eta function, the intriguing integral representations I discovered, and the computational techniques I've developed offer new avenues for exploration. While the MRB constant itself may seem simple at first glance, it seems to reveal unexpected depths upon closer examination.

It's my hope that these findings will spark further interest and lead to even more elegant and surprising results.

Newton said concerning Leibniz's claim to calculus, anyone's thought was published after his, “To take away the Right of the first inventor and divide it between me and that other would be an Act of Injustice.” [Sir Isaac Newton, The Correspondence of Isaac Newton, 7 v., edited by H. W. Turnbull, J. F. Scott, A. Rupert Hall, and Laura Tilling, Cambridge University Press, 1959–1977: VI, p. 455]

Here is what Google says about the MRB constant as of August 8, 2022, at https://www.google.com/search?q=who+discovered+the+%22MRB+constant%22

(the calculus war for CMRB)

CREDIT

https://soundcloud.com/cmrb/homer-simpson-vs-peter-griffin-cmrb

'

In a similar vein to how Newton and Leibniz revolutionized mathematics by distilling the disparate and intricate concepts of their predecessors into the elegant system of calculus, I believe my work on the CMRB constant follows a parallel path.

For centuries, mathematicians have meticulously explored specific series, often leading to intricate and seemingly isolated results. While each series undoubtedly held its own unique charm and contributed to the broader mathematical landscape, they remained confined within the traditional framework of addition and multiplication.

However, by shifting the focus to series involving $n$th roots, I've embarked on a novel approach that transcends these limitations. The CMRB constant and its associated series offer a fresh perspective, unveiling a hidden structure and interconnections that have eluded previous investigations.

Just as calculus opened up new realms of mathematical inquiry and applications, I'm hopeful that my work on the CMRB constant will inspire a similar renaissance in the study of infinite series. By venturing beyond the familiar territory of addition and multiplication, we can unlock a deeper understanding of these mathematical objects and their far-reaching implications.

It's my aspiration that the CMRB constant, like the fundamental constants of physics, will transcend its origins and become a cornerstone in the mathematical edifice, inspiring future generations to explore its mysteries and uncover its full potential.

• $n^{1/n}$ helps understand the limiting behavior of sequences and how quantities change with increasing n.
• It can appear in optimization problems to find the best value for a parameter dependent on n.
• It relates to probability, particularly in problems involving compound interest and approximations.
• It might be used as a parameter in mathematical models in various fields like physics or biology.
• It connects to number theory, such as in the distribution of prime numbers described by the prime number theorem.

§8.

is defined in many languages on the following 32 websites:

• Seznam matematických konstant (in Czech)

• ค่าคงที่ลุ่มแม่น้ำโขง (in Thai);

• ar.wikipedia.org/wiki/ (In Arabic);

• https://calculla.com 300+ calcullators online (in Polish)

• Constante MRB (in French);

• Constanta MRB - MRB constant (in Romanian);

• http://constant.one/ ;

• Crandall, R. E. "The MRB Constant." §7.5 in Algorithmic Reflections: Selected Works. PSI Press, pp. 28-29, 2012,ISBN-10 : ‎193563819X ISBN-13: ‎978-1935638193;

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

• https://en-academic.com/, Wikipedia, Mathematical constant;

• Encyclopedia of Mathematics (Series #94);

• Engineering Tools of the Iran Civil Center (translated from Persian), an international community dedicated to the construction industry, ISSN: 1735–2614;

• Etymologie CA Kanada Zahlen" (in German). etymologie.info;

• Finch, S. R. Mathematical Constants, Cambridge, England: Cambridge University Press, p. 450, 2003, ISBN-13: 978-0521818056, ISBN-10: 0521818052;

• Finch's original essay on Iterated Exponential Constants;

• Finch, Steven & Wimp, Jet. (2004). Mathematical constants. The Mathematical Intelligencer. 26. 70-74. 10.1007/BF02985660;

• Journal of Mathematics Research; Vol. 11, No. 6; December 2019 ISSN 1916-9795 E-ISSN 1916-9809 Published by Canadian Center of Science and Education;

• Library of General Functions (LGF) for SIMATIC S7-1200

• Mauro Fiorentina’s math notes (in Italian);

• https://mathparser.org/mxparser-math-collection/constants/

• MATHAR, RICHARD J. "NUMERICAL EVALUATION OF THE OSCILLATORY INTEGRAL OVER exp(iπx) x^(1/x) BETWEEN 1 AND INFINITY" (PDF). arxiv. Cornell University;

• Mathematical Constants and Sequences a selection compiled by Stanislav Sýkora, Extra Byte, Castano Primo, Italy. Stan’s Library, ISSN 2421-1230, Vol.II;

• "Matematıksel Sabıtler" (in Turkish). Türk Biyofizik Derneği;

• MathWorld Encyclopedia;

• MRB常数 (in Chinese);

• mrb constantとは 意味・読み方・使い方 ( in Japanese);

• MRB константа (in Bulgarian);

• OEIS Encyclopedia (The MRB constant);

• Patuloy ang MRB - MRB constant (in Filipino)

• Plouffe's Inverter;

• the LACM Inverse Symbolic Calculator;

• The On-Line Encyclopedia of Integer Sequences® (OEIS®) as A037077, Notices Am. Math. Soc. 50 (2003), no. 8, 912–915, MR 1992789 (2004f:11151);

• Wikipedia Encyclopedia (in English):

§9.

= B =

and from Richard Crandall in 2012 courtesy of Apple Computer's advanced computational group, the following computational scheme using equivalent sums of the zeta variant, Dirichlet eta:

The expressions and denote the mth derivative of the Dirichlet eta function of m and 0, respectively.

The c_j's are found by the code,

N[ Table[Sum[(-1)^j Binomial[k, j] j^(k - j), {j, 1, k}], {k, 1, 10}]]

(* {-1., -1., 2., 9., 4., -95., -414., 49., 10088., 55521.}*)

Crandall's first "B" is proven below by Gottfried Helms, and it is proven more rigorously, considering the conditionally convergent sum, afterward. Then the formula (44) is a Taylor expansion of eta(s) around s = 0.

At here, we have the following explanation.

Theorem: The MRB constant, (B), and the Dirichlet eta function derivatives satisfy the following relationship:

$$B - \eta^{(1)}(1) = \sum_{m \ge 2} (-1)^{m+1} \frac{\eta^{(m)}(m)}{m!}$$

Proof:

1. Definitions:

• Let (B) be the MRB constant, defined as the conditionally convergent series: $$B = \sum_{n \ge 1} (-1)^n (n^{1/n} - 1)$$
• Define the sequences:

  • $(a_n = (-1)^n (n^{1/n} - 1))$

  • $(b_n = (-1)^n \frac{\log n}{n})$

2Series Manipulation:

Note that $(\eta^{(1)}(1) = \sum_{n \ge 1} b_n) $is also a conditionally convergent series.

Thus, we have the following manipulation, justified by the fact that if two series converge, their difference also converges: $$B - \eta^{(1)}(1) = \sum_{n \ge 1} a_n - b_n = \sum_{n \ge 1} \sum_{m \ge 2} (-1)^n \frac{(\log n)^m}{n^m m!}$$

3 Absolute Convergence:

To rearrange the double sum, we need to establish its absolute convergence. Consider a finite partial sum (S) of the positive terms: $$S = \sum_{n, m} \frac{(\log n)^m}{n^m m!}$$ Rearrange $(S)$ by columns of fixed $(m)$. For $(m = 2),$ an upper bound for the column sum is $$(\frac{\zeta^{(2)}(2)}{2!}).$$ * For $m \ge 3)$, using the inequality $\\log n \le n^{1/2}\ $ for $(n \ge 2),$ we find an upper bound for the (m)-th column: $\sum_{n \ge 2} \frac{(\log n)^m}{n^m m!} \le \sum_{n \ge 2} \frac{1}{n^{m - 1/2} m!} \le \frac{2}{m!(m-2)}$ * Summing these upper bounds gives a convergent series: $$\frac{\zeta^{(2)}(2)}{2!} + \sum_{m \ge 3} \frac{2}{m!(m-2)}$$ * Thus, the double sum is absolutely convergent.

4 Fubini's Theorem and Rearrangement:

• Absolute convergence allows us to apply Fubini's theorem, which justifies the following rearrangement:

  $$\sum_{n \ge 1} \sum_{m \ge 2} (-1)^n \frac{(\log n)^m}{n^m m!} = \sum_{m \ge 2} \sum_{n \ge 1} (-1)^n \frac{(\log n)^m}{n^m m!} = \sum_{m \ge 2} (-1)^{m+1} \frac{\eta^{(m)}(m)}{m!}$$

5 Conclusion:

• This final expression proves the desired relationship between the MRB constant and the Dirichlet eta function derivatives.

$$\blacksquare$$

Key Points:

• Conditional vs. Absolute Convergence: The proof carefully navigates the challenges of manipulating conditionally convergent series by isolating an absolutely convergent portion.
• Fubini's Theorem: The application of Fubini's theorem is crucial to justify the rearrangement of the double sum.
• Upper Bounds and Convergence Tests: The proof utilizes calculus techniques and the integral test to establish the absolute convergence of the double sum.

Central Claim: The MRB constant ( $C_{MRB}$) can be represented as a complex integral involving the cosecant and secant functions:

This is not the same as what we have just proven

if the reply below doesn't say "7,000,000 proven to be accurate digits!" You'll need to refresh the page to see it.

While preparing for the verifying of 7-million digits, I broke some speed records with two of my i9-14900K 6400MHZRAM (overclocked CPUs), using Mathematica 11.3 and the lightweight grid. They are generally faster than the 3 node MRB constant supercomputer with remote kernels! These are all absolute timings! How does your computer compare to these? What can you do with other software?

That last column with Timming ] results here->[7200

For column "=F" (highlighted in green) see linked "10203050100" .

At the bottom, see attached "kernel priority 2 computers.nb" for column =B,

"3 fastest computers together.nb" for column =C

and linked "speed records 5 10 20 30 K"

also speed 50K speed 100k, speed 300k and 30p0683 hour million.nb for column =D .

For the mostly red column including the single, record, 10,114 second 300,000 digit run " =E" is in the linked "3 fastest computers together 2.nb.}

For the partial column of two 6000MHz 14900K' with red text and yellow highlight, see speed 100 300 1M XMP tweaked.

For column "=J," see 574 s 100k , .106.1 sec 50k and 6897s 300k

The 27-hour million-digit computation is found here. <-Big notebook.

This is another comparison of my fastest computers' timings in calculating digits of CMRB:

The blue column (using the Wolfram Lightweight Grid) is documented here.

The i9-12900KS column is documented here.

The i9-13900KS column is documented here.

The 300,000 digits result in the i9-13900KS column is here, where it ends with the following:

  Finished on Mon 21 Nov 2022 19:55:52. Processor and actual time 
         were 6180.27 and 10114.4781964 s. respectively

  Enter MRB1 to print 301492 digits. The error from a 6,500,000 or more digit 
 calculation that used a different method is  

 Out[72]= 0.*10^-301494

Remembering that the integrated analog of the MRB constant is

These results are from the Timing[] command:

The 14900KS at 7200 MHz (extreme tuning!) documented here.

The i9-12900KS column is documented here.

The 2023 i9-13900K column documentation with the 60,000 proven to be accurate digits used to check all of these records, in this link <-Big notebook.

"Windows10 2024 i9-14900KS 6000 MHZ RAM" documentation here

The 2024 with i9-14900KS 5200MHZ records documentation here

Attachments:

3 fastest comput...nb

kernel priority ...nb

moved

§13.

MRB Constant Records,

Google Open AI Chat CPT gave the following introduction to the MRB constant records:

It is not uncommon for researchers and mathematicians to compute large numbers of digits for mathematical constants or other mathematical quantities for various reasons. One reason might be to test and improve numerical algorithms for computing the value of the constant. Another reason might be to use the constant as a benchmark to test the performance of a computer or to compare the performance of different computers. Some people may also be interested in the mathematical properties of the constant, and computing a large number of digits can help to reveal patterns or other features of the constant that may not be apparent with fewer digits. Additionally, some people may simply find the process of calculating a large number of digits to be a challenging and rewarding intellectual pursuit.

My inspiration to compute a lot of digits of C_MRB came from this archived linked 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 having that much precision is the only way to solve such a problem as

1465528573348167959709563453947173222018952610559967812891154^ m-m, where m is the MRB constant, which gives the near integer "to beat all," 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 are reproducible results with methods. The utmost care has been taken to assure the accuracy of the record number of digit calculations. These records represent the advancement of consumer-level computers, 21st-century Iterative methods, and clever programming over the past 23 years.

Here are some record computations of C_MRB. Let me know if you know of any others!

1 digit of the

C_MRB with my TI-92s, by adding -1+sqrt(2)-3^(1/3)+4^(1/4)-5^(1/5)+6^(1/6)... as far as practicle, 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 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 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][10]   if you can read the printed and scanned copy there.

Sigma still can be found here.

5,000 digits of CMRB in September of 1999 in 2 hours on a 350 MHz PentiumII,133 MHz 64 MB of RAM using the simple PARI commands \p 5000;sumalt(n=1,((-1)^n*(n^(1/n)-1))), after allocating enough memory.

To beat that, it was done on July 4, 2022, in 1 second on the 5.5 GHz CMRBSC 3 with 4800MHz 64 GB of RAM by Newton's method using Convergence acceleration of alternating series. Henri Cohen, Fernando Rodriguez Villegas, Don Zagier acceleration "Algorithm 1" to at least 5000 decimals. (* Newer loop with Newton interior. *)

documentation here

And here

I did it using an i9-14900K, overclocked, with 64GB of 6400MHz RAM. I used my own program. Processor and actual time were 0.796875 and 0.8710556 s, respectively.

 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,

To beat that, it was done in <2.5 seconds on the MRBCSC 3 on July 7, 2022 (more than 14,400 times as fast!)

documentation here

To beat that, it was done in <1. 684 seconds on April 10, 2024 (more than 21,377 times as fast!). documentation [here][19]:
In[3]:= 10 hour*3600 seconds/hour/(1.684 seconds)

Out[3]= 21377.7

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. The 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, The max memory used was 5.0 GB of RAM.

It looked similar to this stock image:

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. The max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.
To beat that, on the 4th of July 2022, the same digits in 1/4 of an hour using the MRB constant supercomputer.
To beat that, on the 7th of July 2022, the same digits in 1/5 of an hour. 
To beat that, on the 4th of April 2024, the same digits in 1/6 of an hour. using a pair of i9-14900Ks in parallel (100,000% as fast as the first 100,000 run by a GHz Core 2 Duo!)

see one sixth hour hundred k.

 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. The 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. The 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. The max memory used was 91 GB of RAM. The Mathematica 6.0 code is used as 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 at 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. using Mathematica 6.0 for Microsoft Windows (64-bit) (June 19, 2007), which averages 7.44 seconds per digit.using a Dell Studio XPS 8100 i7 860 @ 2.80 GHz with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929 GB of 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 as 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, 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 of CMRB 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 was on a 2.93 GHz 8-core Nehalem,  1066 MHz, PC3-8500 DDR3 ECC RAM.

    To beat that, in Aug of 2018, 1,004,993 digits 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: 1,004,993 digits 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, 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, over 1,004,993 correct digits 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  for documentation.

    To beat that, a 1,004,993 correct digits computation in 36.7 hours of absolute time and only 26.4 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 30 cores were clocked at up to 5.2 GHz.



    To beat that, a 1,004,993 correct digits computation in 31.2319  hours of absolute time and 16.579  hours of computation time from the Timing[] command using 3/4 of the MRB constant supercomputer 4, finishing Dec 5, 2022. Ram Speed was 5200MHz, and all of the 24 performance cores were clocked at up to 5.95 GHz, plus 32 efficiency cores running slower. using 24 kernels on the Wolfram Lightweight grid over an i-12900k, 12900KS, and 13900K.
    To beat that, a 1,004,993 correct digits computation in 30. hours of absolute time on Marh 21, 2024.
    To beat that, a 1,004,993 correct digits computation in 27. hours

The 27-hour million-digit computation is found here <-Big notebook

see also 30 hour million

36.7 hours million notebook

31.2319 hours million

 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. see https://www.wolframcloud.com/obj/bmmmburns/Published/36%20hour%20million.nb

for details.

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. using a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz.

 3,014,991 digits of CMRB,  world record computation of **C**<sub>*MRB*</sub> was finished on Sun 21 Sep 2014 at 18:35:06. It took one month 27 days, 2 hours 45 minutes 15 seconds. The processor time from the 3,000,000+ digit computation was 22 days.The 3,014,991 digits of **C**<sub>*MRB*</sub> with Mathematica 10.0. using Burns' new version of Richard Crandall's code in the attached 3M.nb, optimized for my platform and large computations. Also, 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 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 were finished on Wed 16 Jan 2019, 19:55:20. It took four 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 information is available upon request.

 More than 5 million digits of CMRB were found on Fri 19 Jul 2019, 18:49:02; methods are described in the reply below, which begins with "Attempts at a 5,000,000 digit calculation ."   For this 5 million digit calculation of **C**<sub>*MRB*</sub> 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.

Six million digits of CMRB after eight 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 accurate to 5024993 decimals!!!

5,609,880, verified by two distinct algorithms for x^(1/x), digits of CMRB 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 in 160.805 days.

6,500,000 digits of CMRB on my second try,

Successful code was:

In[2]:= Needs["SubKernels`LocalKernels`"]
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]

The MRB constant supercomputer replied,

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
the calculation that used a different method is 
0.*10^-6029992.

"Computation time" 72.526 days.

 "Absolute time" 185.491 days.

It would have taken my first computer, a TRS-80 at least 4307 years with today's best mathematical algorithms. 15 GHz/1.77 MHZ 185.491 days1 year/(365 days)

It was instantly checked to 6,029,992 or so, digits by the program itself. A 7-million-digit run using different number of digits of Exp[Log[ll]/ll] computed by each method, is in process, which will verify the residue of digits.

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:

2nd 6p5 million.nb

6p5millionMRB.nb

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 1st fourth.nb."

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:

5p5million.nb

MRBSC2 6 million...nb

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 s and 1.38935720536301*10^7 s. or 61 days and 161 days 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:

MRBSC2 6 million...nb

On 2/24/2020 at 4:35 pm, I started a 10,000 digit calculation of the MRB constant using the integral

Here 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:

MRB to 25k confi...txt

comp of 25k and ...nb

comp of 25k conf...nb

up to 50k digits...nb

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:

4 million 11 2018.nb

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.

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.

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

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

rec

Sent from my iPhone."

Nice work. Worth a bit of excitement, I' d say.

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

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.