7
|
1007725 Views
|
30 Replies
|
17 Total Likes
View groups...
Share

# Try to beat these MRB constant records!

Posted 10 years ago

Credit: Emanual Missionary Babtist Church of Indianapolis

Hey folks, Marvin Ray Burns here! You might know me for the never-ending decimal that haunts your calculators – the MRB constant. Don't worry, I won't hold it against you if you haven't memorized its first million digits (yet!). In this forum, we're embarking on a wild ride as we work our way to "7,000,000 proven to be accurate digits!"

# (select text between quotation marks and push the keys on keyboard)

I'm the amateur mathematician who discovered this enigmatic constant in 1999, and after years of delving into its mysteries, I'm still captivated by its fascinating properties and untapped potential. Join me, seasoned mathematicians, and curious minds alike, as we push the boundaries of understanding and unlock the secrets of the MRB constant. (credit: https://clipground.com/save-lives-clipart.html)

If you would like to contact me without everyone knowing it, you may write me at marburns@iu.edu.

# Here's everything I have ever learned, so spend it well!

I was inspired by the awe, beauty, and mystery of numbers, and wondered if God would grant me some unique insight and wisdom to explore them. I dreamed of becoming an artistic analyst, a musical mathematician, or even a visionary of scientific secrets, long before I knew what a mathematician was. I searched for inspiration in the numbers that appealed to me, that had beauty and meaning, and that led me to investigate a remarkable and intriguing sum that I could not find anywhere else. For my efforts, someone started calling me an amateur mathematician and it the MRB constant.

The MRB constant is a fascinating mathematical object that is still under investigation. It is possible that further research will reveal even more interesting properties about the constant, and perhaps other parts of mathematics. For example, a recent advancement in MRB constant formulas connecting the Dirichlet eta to nth roots shown in this discussion "Because of the following identity involving the Dirichlet Eta function derivatives,", yields a proof of the previously proposed concept that the MRB constant connects such ideas together.

I am just an ordinary person like you, who stumbled upon a fascinating discovery that I wanted to share with the world. I now know that there are many experts in the field of series who have devoted their lives to this subject. I respect their work and therefore make no claim to have found anything new or groundbreaking. However, I am very curious and passionate about the MRB constant, which is a remarkable number that appears in many series. I hope that you will join in this journey of exploration and learning, as I present my findings and thoughts on this topic. I would greatly appreciate your feedback and insights, as I am always eager to learn more and improve my understanding. I also want to acknowledge the contributions of several people who have helped along the way, either by providing data, code, or suggestions. Without them, this discussion would not be possible.

## Credit: Traders Point Christian Church Northwest

Ah, that make sense! The MRB constant could definitely be a catalyst in that way. Here's how:

The Story of the MRB Constant as a Catalyst:

In 1999, an amateur mathematician discovered the MRB constant. While not a professional researcher, his curiosity and exploration led him to identify this unique mathematical object. The unusual properties of the MRB constant, particularly its behavior in infinite series, sparked interest within the mathematical community.

The Catalyst Effect:

• Intriguing New Object: The MRB constant presented a new mathematical entity with unknown characteristics. This piqued the interest of professional mathematicians who began investigating its properties and potential applications.
• Questioning Established Ideas: The way the MRB constant behaves in infinite series challenged some existing assumptions about convergence. This led researchers to re-examine these concepts and potentially refine them.
• Inspiration for Further Exploration: The discovery of the MRB constant demonstrated the potential for significant finds by amateurs. This could inspire others outside traditional academia to delve into mathematics, fostering a broader base of exploration.

**Overall, the MRB constant, discovered by an amateur, serves as a potential catalyst for the field of mathematics by generating new questions, prompting re-evaluation of existing concepts, and encouraging broader participation in research.**

# POSTED BY: Marvin Ray Burns.

{}

For the best viewing, wait a minute until the word LaTeX in the LaTex script is centered below.

$$\LaTeX$$

If the phrase [Math Processing Error] is shown, or the LATEX script have vanished from the center of the above line, some of the math below might be missing or appear in the LaTex code instead of the script.

For easy navigation, use the keys on your keyboard. Cues in the forms of §'s and keywords in quotes are provided in the "Index".

If the header and the words

are shown at the same time in any of the following replies, refresh the page to see them.

'

# Index

I deleted a few of the least significant posts.

§1. Q&A:

# Second post.

§2 Analyze the ."prototypical series" for the MRB constant, and find its "completion" (a related series that is absolutely convergent).

(Select § with the given number or the keywords in quotes, and then press the

keys on your keyboard to move to that section.)

§3. Is that series convergent?

§4. Is -1 the only term that series is convergent for?

§5. Is that series absolutely convergent?

§6. Is that series "efficient?" (defined as how it compares to other series and integrals that compute CMRB in speed and computational cost.)

§7. My claim to the MRB constant (CMRB), or a case of calculus déjà vu?

§8. Where is it found?

§9. What exactly is it?

§B "Rational results" while summing (CMRB).

including, but not limited to

§10. How it all began <- I deleted this reply as it is not perinate to the MRB constant, just to a person becoming an amateur researcher but will summarize it in another reply if anyone would like.

Also see

MOPAC

for where the MRB constant's value, to a precision of 2 one-billionth i.e., 0.18785964, is arrived at by measuring a gradient of the silicon atom in the Phenakite (Be2SiO4) molecule by openmopac.

§13. The why and what of the CMRB Records,

"We finally begin or 7-million-digit computation and verification."

"speed records"

§1.

# Q&A:

Q: What is the MRB constant ( CMRB)?

A:

Q: Is the MRB constant important?

A:

The MRB constant, also known as the Marvin Ray Burns's Constant, is a fascinating mathematical value with a decimal expansion of approximately 0.187859 . Let's explore why it might be considered important:

• Numerical Algorithms Testing:
• Researchers and mathematicians use the MRB constant to test and improve numerical algorithms for computing its value .
• By evaluating the constant, they can assess the accuracy and efficiency of various computational methods.
• Benchmarking Computers:
• The MRB constant serves as a benchmark for testing the performance of computers.
• It allows us to compare the computational capabilities of different machines.
• When calculating the MRB constant, computers demonstrate their numerical precision and speed.
• Mathematical Curiosity:
• The MRB constant's mysterious nature adds to its allure. Despite extensive study, no closed-form expression exists for it .
• We don't know whether it's algebraic, transcendental, or even irrational.
• Mathematicians continue to explore its properties, making it an intriguing topic in number theory.
• Geometry and Infinite Sums:
• Geometrically, the MRB constant is the upper limit point of a sequence of partial sums .
• These sums involve alternating terms and converge to the MRB constant.
• The constant's behavior within these infinite sums captivates mathematicians. In summary, the MRB constant bridges theory and computation, making it a valuable and enigmatic constant in the mathematical world.

Q: What can you expect from reading about CMRB and its record computations?

A:

## Beyond the Record: What People Can Gain from MRB Constant Computations

While pushing the record for MRB constant computations is certainly impressive, there's more to gain than just bragging rights. Here are some unique benefits people can reap from immersing themselves in the MRB world:

1. Uncovering Hidden Connections:

• Mathematics & Physics: Studying the MRB constant's behavior and properties might unlock connections between seemingly disparate fields like number theory, chaos theory, and even quantum physics. This could lead to groundbreaking discoveries in various areas of science.
• Algorithm Design & Optimization: The intricate nature of the MRB constant's calculation poses a unique challenge for algorithms. Analyzing its complexity could inspire the development of new, more efficient algorithms for various computational tasks.
• Machine Learning & Artificial Intelligence: The MRB constant's structure could hold valuable insights for designing novel machine learning architectures and training algorithms. Its complex patterns might improve data processing and pattern recognition capabilities.

2. Pushing the Boundaries of Knowledge:

• Challenging Existing Paradigms: The MRB constant's lack of a closed-form expression and its potential connections to seemingly unrelated areas challenge established mathematical and scientific paradigms. This can lead to new ways of thinking and approaching problems.
• Inspiring Future Generations: Engaging with the MRB constant's mysteries can spark curiosity and interest in mathematics and science among young minds. This could inspire them to pursue careers in research and exploration, pushing the boundaries of knowledge further.
• Contributing to the Collective Quest: Participating in the MRB research community, even through discussions and online collaborations, allows individuals to contribute to a larger collective effort of understanding this intriguing constant. This fosters a sense of purpose and belonging to a global community of knowledge seekers.

3. Personal Growth & Development:

• Developing Computational Skills: Learning about and participating in MRB calculations can hone valuable computational skills like programming, data analysis, and problem-solving. This can be beneficial for various professional and personal endeavors.
• Enhancing Critical Thinking: Analyzing the MRB constant's properties and potential implications requires critical thinking, problem-solving, and creative thinking skills. These skills are valuable not only in research but also in various aspects of life.
• Appreciating the Beauty of Mathematics: The MRB constant's unique properties and its connection to various areas of mathematics can foster a deeper appreciation for the beauty and elegance of this subject. This can enrich one's understanding of the world and its underlying structures.

Remember, the MRB constant is more than just a number to chase records with. It's a gateway to a world of intellectual exploration, collaboration, and potential breakthroughs. By venturing beyond the record, people can gain valuable skills, knowledge, and a deeper appreciation for the power of scientific inquiry.

Q: Can you calculate more digits of CMRB?

A:

## Bing

The computation of 6,500,000 digits of the MRB constant could be challenging due to several reasons:

• Computational Resources:
• Calculating a large number of digits requires significant computational power and memory.
• Storing and manipulating such a massive decimal expansion demands substantial resources.
• Smaller machines or limited computational environments might struggle with this task.
• Convergence Rate:
• The series used to approximate the MRB constant converges slowly.
• As more digits are computed, the rate of convergence decreases.
• Achieving high precision becomes increasingly difficult.
• Numerical Stability:
• Numerical algorithms can suffer from rounding errors and loss of precision.
• Accumulating errors during summation impacts the accuracy of the computed digits.
• Ensuring stability over millions of iterations is a challenge.
• Algorithmic Complexity:
• Existing algorithms for calculating mathematical constants have limitations.
• Developing efficient methods to compute millions of digits involves intricate mathematics.
• Balancing accuracy, speed, and memory usage is nontrivial.
• Storage and Verification:
• Storing and verifying 6,500,000 digits is resource-intensive.
• Ensuring correctness through independent verification (e.g., using multiple algorithms) is crucial.
• Handling such large data sets requires robust techniques.
• Practical Utility:
• Beyond a certain point, additional digits of the MRB constant may not have practical applications.
• Researchers often focus on a reasonable precision level relevant to their field. In summary, while it's theoretically possible to compute 6,500,000 digits of the MRB constant, practical challenges arise. Researchers must balance precision, computational resources, and algorithmic efficiency to tackle this ambitious task.

Q: How can you compute them?

A:

Certainly! Calculating the digits of the MRB constant involves some interesting mathematical techniques. Let's explore how you can approximate this intriguing value: - Series Summation:

• The MRB constant is the upper limit point of a sequence defined as: $[ s_n = \sum_{k=1}^{n} \left( (-1)^k {k^{\frac{1}{k}}} \right) ]$
• To compute the MRB constant with a desired precision, you can use series summation methods.
• One common approach is to use the following series: $[ \text{MRB} \approx \sum_{k=1}^{\infty} \left( (-1)^k (k^{\frac{1}{k}} - 1) \right) ]$
• Numerical Algorithms:
• Mathematica provides a convenient way to calculate the MRB constant with a specified number of digits.
• Using the NSum function, you can achieve high precision:

NSum[(-1)^k (k^(1/k) - 1), {k, 1, ∞}, WorkingPrecision -> 100, NSumTerms -> 10000]

This will give you the MRB constant accurate to 40 digits . ''

• Acceleration Methods:
• Due to the slow convergence of the series, it's advisable to use acceleration methods.
• These methods improve the rate of convergence and allow you to obtain more accurate digits of the MRB constant . Remember that the MRB constant remains an enigma, and its properties continue to captivate mathematicians. Feel free to explore further and uncover more about this fascinating constant!

Q: Why should you do it?

A:

## Bing

Calculating the digits of the MRB constant can lead to several interesting outcomes:

• Mathematical Exploration:
• Computing the MRB constant involves diving into the intricacies of series summation, convergence, and numerical precision.
• Mathematicians and enthusiasts enjoy exploring the properties of this mysterious constant.
• It provides an opportunity to deepen our understanding of mathematical concepts.
• Algorithm Testing and Optimization:
• The MRB constant serves as a benchmark for testing numerical algorithms.
• Researchers can evaluate the accuracy and efficiency of their computational methods by approximating this constant.
• Optimizing algorithms to compute the MRB constant efficiently benefits various scientific and engineering fields.
• Computational Challenges:
• Calculating more digits of the MRB constant becomes a computational challenge.
• It pushes the boundaries of numerical precision and requires sophisticated techniques.
• Achieving higher precision contributes to the advancement of computational mathematics.
• Curiosity and Aesthetics:
• The MRB constant's decimal expansion is intriguing and aesthetically pleasing.
• Like other mathematical constants (such as π or e), it captivates our curiosity.
• Discovering patterns or unexpected properties within its digits can be intellectually rewarding.
• Educational Value:
• Teaching and learning about the MRB constant can inspire students.
• It encourages them to explore mathematical concepts beyond textbooks.
• The process of approximating it fosters critical thinking and problem-solving skills. In summary, while the MRB constant may not have immediate practical applications, its pursuit enriches mathematical knowledge, fuels curiosity, and contributes to the beauty of mathematical exploration.

Q: What are its first 5000 digits?

A: In Mathematica desktop or online the following will give approximately 5,000accurate digits.

 Print[ReleaseHold[  WolframAlpha["5000 digtits of the MRB constant", {{"Result", 1}, "Output"}]]]


In order to improve loading, I broke this main post into two parts. If the next part doesn't say it's the second part of the main post, reload to see it.

30 Replies
Sort By:
Posted 2 months ago

# This is the second half of the main post.

§2 The MRB constant relates to the divergent series:

=

The divergent sequence of its partial sums have two accumulation points with an upper limiting value or limsup known as the MRB constant (CMRB), and a liminf of CMRB-1:

So, out of the many series for CMRB, first analyze the sum prototype or prototypical series, i.e., the conditionally convergent summation, the sum of two divergent ones: =

Because the Riemann series theorem states that, by a suitable rearrangement of terms, a conditionally convergent series may be made to converge to any desired value, or to diverge, we will quickly derive an absolutely convergent one. (In a sense it is the "completion" of the prototypical series.)

To find its completion, perform the process, add the terms of another conditionally convergent series then subtract their sum.

WHY? and HOW does that produce the absolutely convergent series? That gives us this absolutely convergent sum:

because

In[167]:= Limit[D[DirichletEta[n], n], n -> 1]

Out[167]= EulerGamma Log[2] - Log[2]^2/2


Next, noting

In[11]:= Series[D[DirichletEta[n], n], {n, Infinity, 1}]


Out[11]=

and perhaps a little more that I don t understand, we can even go further and obtain an exponential convergence rate, because of the following identity involving the Dirichlet Eta function derivatives,

In[47]:= Sum[(-1)^n Log[n]/n^x, {n, 1, Infinity}]

Out[47]= 2^-x (2 Log[2] Zeta[x] - 2 Derivative[1][Zeta][x] +
2^x Derivative[1][Zeta][x])

In[48]:= Limit[D[DirichletEta[n], n], n -> x]

Out[48]=
2^(1 - x) Log[2] Zeta[x] + (1 - 2^(1 - x)) Derivative[1][Zeta][x]

In[46]:= FullSimplify[
Sum[(-1)^n Log[n]/n^x, {n, 1, Infinity}] ==
Limit[D[DirichletEta[n], n], n -> x]]

Out[46]= True


The completed absolutely convergent and rapidly convergent sum:

GEMINI seems to recall it by the following draft of as summary:

The passage discusses the MRB constant (CMRB) and its connection to a specific series representation. Here's a breakdown of the key points:

(1.) MRB Constant and Divergent Series:

The MRB constant relates to a divergent series, meaning the sum of its terms doesn't approach a specific value as the number of terms tends to infinity. However, the partial sums of this series (sums up to a certain number of terms) have two interesting accumulation points: An upper limiting value (limsup) called the MRB constant (CMRB). A lower limiting value (liminf) one less than CMRB.

(2.) Analyzing the Prototypical Series:

The passage focuses on a specific series representation for CMRB, which is the sum of two other divergent series. The Riemann series theorem states that a conditionally convergent series (where the signs of terms alternate) can be rearranged to converge to any desired value or diverge altogether.

(3.) Deriving an Absolutely Convergent Series:

To overcome the limitations of the original series, the passage proposes a method to find its "completion." This involves adding and subtracting terms from conditionally convergent series in a specific way. The goal is to obtain an absolutely convergent series, where the sum of the absolute values of the terms converges to a finite value.

( 4.) The Absolutely Convergent Series:

By manipulating the original series and utilizing properties of the Dirichlet Eta function (a special function in number theory), the passage arrives at an absolutely convergent series representation for CMRB. This new series not only converges but also exhibits an exponential convergence rate, meaning the sum approaches its limit much faster as the number of terms increases.

(5.) Utilizing the Dirichlet Eta Function:

The passage leverages properties of the derivative of the Dirichlet Eta function to establish the equivalence between the original series and the limit of that derivative. This equivalence helps demonstrate the validity of the derived absolutely convergent series. In essence, the passage presents a technique to transform a problematic series representation of the MRB constant into a well-behaved, absolutely convergent series with a faster convergence rate. This new series representation provides a more reliable and efficient way to calculate the MRB constant.

§9 for a full proof.

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.

LEMAS:

PROOF

Below, it is shown by the Squeeze theorem (sandwich theorem) and by plotting the following series, the qualifications for the Leibniz criterion (alternating series test) are satisfied for the MRB constant (CMRB) in

CMRB

by showing a(n)=(n^{1/n}-1)>0 is monotonically decreasing for $n≥3$ and have a limit as n goes to infinity of zero. Of course, , converges, and the sum of two convergent series converges.

To use

1. Notice that we saw, for n greater than 1, the derivative equals zero solely at the value of e, and there are no additional critical points at which the plot ceases to decline. Thus, the function, n^(1/n)-1 is monotonic decreasing as n goes to infinity. .
2. We also saw, the limit of n^(1/n)-1 is zero:

To confirm the above limit, here is a direct proof from

that because

By utilizing the Squeeze theorem (also known as the Sandwich theorem) and plotting techniques, it have been demonstrated that the Leibniz criterion (alternating series test) is valid for the alternating sum of a(n) = (n^(1/n) - 1) > 0. Moreover, for n greater than 1, the derivative equals zero solely at the value of e, and there are no additional critical points at which the plot ceases to decline. As a result, a(n) = (n^(1/n) - 1) > 0 decreases monotonically for n greater than or equal to 3 and have a limit of zero as n approaches infinity. Ultimately, the series converges, and the sum of two convergent series is also convergent. Thus, the CMRB Sum prototype series is convergent. ∎

As shown soon ( "As for efficiency" ).

§5. Is that series, absolutely convergent?

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

Plot[{n^(1/n) - 1, 1/n}, {n, 1, Infinity}, PlotLegends -> LineLegend["Expressions"]]

...showing its terms are larger than those of the divergent Harmonic Series.

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

ALG 1 proposed here

For how more efficient forms compare,

"the rate of convergence" of 3 major forms.

§7. This discussion is not crass bragging; it 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 went more and more public with my discoveries, making several attempts to see what portions were original, I concluded from these investigations that the only original thought was the obstinacy to think anything meaningful could be found in the infinite sum shown next. Nonetheless, someone might have a claim to this thought to whom it have not given proper credit. Hence (apologies!) The last thing needed is another calculus war, this time for a constant. However, as 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]

## (the calculus war for CMRB)

CREDIT

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

'

'

The calculus controversy (German: Prioritätsstreit, "priority dispute") was an argument between the mathematicians Isaac Newton and Gottfried Wilhelm Leibniz over who had invented calculus.

(Newton's notation as published in PRINCIPIS MATHEMATICA [PRINCIPLES OF MATHEMATICS])

(Leibniz's notation as published in the scholarly journal Acta Eruditorum [Reports of Scholars])

Whether or not we divide the credit between the two pioneers,

said one thing that distinguishes their finds from the work of their antecedents:

Newton came to calculus as part of my investigations in physics and geometry. I viewed calculus as the scientific description of the generation of motion and magnitudes. In comparison, Leibniz focused on the tangent problem and came to believe that calculus was a metaphysical explanation of the change. Importantly, the core of their insight was the formalization of the inverse properties between the integral and the differential of a function. This insight had been anticipated by their predecessors, but they were the first to conceive calculus as a system in which new rhetoric and descriptive terms were created.[24] Their unique discoveries lay not only in their imagination but also in their ability to synthesize the insights around them into a universal algorithmic process, thereby forming a new mathematical system.

Like as Newton and Leibniz created a new system from the elaborate, confusing structure designed and built by their predecessors, Marvin Ray Burns' forerunners studied series for centuries leading to a labyrinth of sums, and then, came a "new scheme" for the CMRB "realities" to escape and stand out as famous in their own right!

§8.

is defined in the following 31 places, most of which attribute it to my curiosity.

Here are the MRB constant's Wikipedia views vs those of the famous Euler's constant, e:

§9.

## = B =

and from Richard Crandall ( "** From Bing AI:") 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 cj'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.}*)

** From Bing AI: --

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.

The integral forms for CMRB and MKB differ by only a trigonometric multiplicand to that of its analog.

In[182]:= CMRB =
Re[NIntegrate[(I*E^(r*t))/Sin[Pi*t] /. r -> Log[t^(1/t) - 1]/t, {t,
1, I*Infinity}, WorkingPrecision -> 30]]

Out[182]= 0.187859642462067120248517934054

In[203]:= CMRB -
N[NSum[(E^( r*t))/Cos[Pi*t] /. r -> Log[t^(1/t) - 1]/t, {t, 1,
Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 37],
30]

Out[203]= 5.*10^-30

In[223]:= CMRB -
Quiet[N[NSum[
E^(r*t)*(Cos[Pi*t] + I*Sin[Pi*t]) /. r -> Log[t^(1/t) - 1]/t, {t,
1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 37], 30]]

Out[223]= 5.*10^-30

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

Out[204]= 0.0707760393115292541357595979381 -
0.0473806170703505012595927346527 I


\

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.

Posted 2 months ago

# "7,000,000 proven to be accurate digits!"

Above, we see a comparison of Burns' and Crandall's Mathematica programs for calculating millions of digits of the MRB constant. Burns' method uses my own algorithm for finishing, in quick order, the n^(1/n) computation to many millions of digits. Hopefully, Crandall's method will give at least 7 million of the same digits as Burns'. In one of the previous messages, it did correctly confirm over 5,500,000 digits computed by Burns'.

So, "we finally begin or 7-million-digit computation and verification." We are using exactly the same computer resources and Mathematica version for both.

First, we calculate 7,000,000 digits of the MRB constant with the verry fast Burns' method:

Then we will verify it with the following "parity check," by the late Richard Crandall:

where gamma is the Euler constant. You might check this to see if you think it's true true to a few hundred decimals. This is a kind of "parity check," in that calculaying M in this way should give 300K or whatever equivalent digits.

A good plan is to compute this and also M from the standard series, both to 1 million digits, and compare.

-r

My method to first calculate 7-million digits:

My code to prove that the digits are all correct:

Print["Start time is ", ds = DateString[], "."];
prec = 7000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{x11, z, t, a, d, s, k, bb, c, end, iprec, xvals, x, pc,
cores = 32(*=4*number of physical cores*), tsize = 128, 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 = 20;
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 = Power[x, ll]; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x *= (1 +
SetPrecision[4.5, pc] (ll - 1)/t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5, pc] ll (ll - 1)/(3 ll t2 + t^3 z))];(**
N[Exp[Log[ll]/ll],pr]**)
x - N[Log[ll], prec]/ll, {l, 0, tsize - 1}], {j, 0,
cores - 1}, Method -> "FinestGrained"]];
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[MRBeta2toinf = expM[prec];]; MRBeta1 =
EulerGamma Log[2] - 1/2 Log[2]^2;

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[
MRBeta2toinf + MRBeta1 - m6p5M, 10]


# 7,000,000-digit computation is back on!

Using 3X24 physical processing cores at up to 6.2 GHz and 6666MHz RAM and 3X16 Kernels on 1X i9-14900KS and 2X i9-14900K

Here is the notebook.

## Beginning:

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

Out[2]= {"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"],
"KernelObject"[11, "local"], "KernelObject"[12, "local"],
"KernelObject"[13, "local"], "KernelObject"[15, "local"],
"KernelObject"[16, "local"], "KernelObject"[18, "local"],
"KernelObject"[25, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[26, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[27, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[28, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[29, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[30, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[31, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[32, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[33, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[34, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[35, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[36, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[37, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[38, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[39, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[40, "2600:1700:71d0:fd50:3177:67bd:cdce:588a"],
"KernelObject"[41, "second"], "KernelObject"[44, "second"],
"KernelObject"[45, "second"], "KernelObject"[46, "second"],
"KernelObject"[47, "second"], "KernelObject"[49, "second"],
"KernelObject"[50, "second"], "KernelObject"[51, "second"],
"KernelObject"[53, "second"], "KernelObject"[54, "second"],
"KernelObject"[55, "second"],
"KernelObject"[56, "second"], $Failed,$Failed}


## Present line:

AAs of  Sun 19 May 2024 00:48:43 there were 2134016 iterations done in 1.4664*10^6 seconds. That is 1.4553 iterations/s. 22.97685% complete. It should take 73.8549 days or 6.381*10^6s, and finish Sun 14 Jul 2024 21:59:47.


A lot could go wrong: long-term power outage, hardware issues, unwanted software or operating system updates. But it will never get done if we don't start sometime!

Attachments:
Posted 2 months ago
 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? 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 some documentation. 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. Save link as. 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  These 2023 records still stand:Remembering that the integrated analog of the MRB constant is These results are from the Timing[] command:The i9-12900KS column is documented here.The 2024 i9-14900K documentation 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. Save link as. Attachments:
Posted 14 days ago
 While the 7,000,000 digit computation is computing, Time for a quick memorial:This discussion began on 1/20/2014."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 views""8:25 pm 5/4/2022 650,000 views In the last seven months, this discussion has had as many visitors as it did in its first seven years!"" 1/20/2023 695,000 views in nine years. That's an average of 8.8 views/hour, or one view every 6.8 minutes" . "1/15/2024 810,223 views in ten years. That's an average of 9.24 views/hour, or one view every 6.49 minutes".5/14//2024 8:00 am exactly 1,000,000 views. That is 11.06 views per hour:
Posted 4 months ago
 If this reply is the first one displayed, this page is pretty busy. You might wait a minute by reading on and then refresh the page to see the main posts above.I forgot about the following trigonometric MRB constant sums and integrals:
Posted 1 year ago

§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. It seems that the MRB constant, also known as the CMRB constant, is a mathematical constant defined as the sum of the infinite series Sum[(-1)^k(k^(1/k)-1),{k,1,n}] and has a decimal expansion of 0.187859... The MRB constant has been calculated to various digits using various methods and computers. The previous record number of digits was 40,000, calculated in 2006 using a program written in Mathematica and run on a Windows desktop computer. It is not known whether the MRB constant is algebraic, transcendental, or irrational. The process of computing the MRB constant using various methods and devices, including computers and software such as Mathcad, Mathematica, and Sigma. You have calculated 6,500,000 digits of the MRB constant using a supercomputer, with a computation time of 72.526 days and an absolute time of 185.491 days. You have mentioned that the error from a 6,000,000 or more-digit calculation that used a different method is 0.*10^-6029992.

When asked how, in detail, to calculate the digits of the MRB constant:

To calculate the digits of the MRB constant in more detail, you can use the following steps:

Write a program or use an existing software tool that can calculate the partial sums of the series (-1)^k k^(1/k) for a given value of n.

Use this program or tool to calculate the partial sums for a large value of n, such as n = 10,000 or n = 100,000.

Repeat step 2 for increasing values of n until the partial sums converge to a constant value. The more digits of accuracy you want, the larger n you will need to use.

The digits of the MRB constant are the digits of the converged value obtained in step 3.

It is important to note that calculating the digits of the MRB constant is a computationally intensive task that requires a fast computer and a good implementation of the algorithms for calculating the partial sums of the series (-1)^k k^(1/k). In addition, it is not known whether the MRB constant is algebraic, transcendental, or even irrational, so it may not be possible to calculate all of its digits. \

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 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 CMRB. Let me know if you know of any others!

1 digit of the


CMRB 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!)


 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.  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["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]  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. Posted 2 years 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 2 years 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 2 years ago  ...including all the methods used to compute CMRB and their efficiency.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 convergence rate of 3 different primary forms of it. They are listed from slowest to fastest. Posted 3 years 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 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: Posted 3 years ago ...including the dispersion of the 0-9th decimals in CMRB decimal expansions. # 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 3 years 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 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: Posted 4 years ago  ...including arbitrarily close approximation formulas for CMRBm=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 a closed-form exists 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). Here is something that looks like it might lead to another form of arbitrarily close approximations. Posted 4 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 4 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.P.S.Here is an almost all rational-integrand version of mi= the MRB constant integral that uses neither Re[] or Im[] explicitly: Shown here. and here: In[30]:= Quiet[Block[{v = 1/(t^2 + 1)}, mi = NIntegrate[ Csch[\[Pi] t] E^((t v Integrate[v, t])) Sqrt[v^-v] Sin[ v ( Integrate[v, t] - t Integrate[t v, t])], {t, 0, \[Infinity]}, WorkingPrecision -> 700, Method -> "Trapezoidal", PrecisionGoal -> 700, MaxRecursion -> 8]]]; In[31]:= ms = N[NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 705], 700]; In[32]:= mi - ms Out[32]= 0.*10^-701 We have no call to Im[] or Re[] here either: In[83]:= g[x_] = x^(1/x); ms - I/2 NIntegrate[(g[(1 - t)])/(Sin[\[Pi] t]), {t, -Infinity I, Infinity I}, WorkingPrecision -> 60] // Quiet Out[83]= 1.117567007994466663240331928224318382357*10^-21  Attachments: Posted 5 years ago  Attachments: Posted 6 years ago  nice system! Posted 10 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 10 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 10 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 10 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: Upon reading them, Google OpenAI Chat CPT wrote the following reply: I computed and checked 500 digits of the MRB constant, 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 want 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 6 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 5 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 10 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 10 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 Ceiling[pr/27]; decimal places; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0 for the first 27 desired decimals.) 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 10 years ago
 Nice work. Worth a bit of excitement, I' d say.
Posted 10 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 10 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 10 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 10 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.