# Try to beat these MRB constant records!

Posted 9 years ago
716632 Views
|
63 Replies
|
17 Total Likes
|

,

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

That CMRB nomenclature for the MRB constant, introduced above, and used extensively below, was devised by Wolfram Alpha, as shown next.

'

An Easter egg for you to find below:

RABBIT HOLE #!,

As a result, delving into "constructing rather than finding" math leads to RABBIT HOLE #1. Here are three unresolved inquiries:

• If we assume that the MRB constant exists and that the author created it, did its properties exist before its invention?
• If they did not, does that imply that the author also invented these properties?
• If so, does the same principle hold that the originators of all mathematical constructs, such as numbers, relations, theorems, shapes, etc., also invented all unintended consequences?

# Index

## The first post

For section 0, highlight text between quotes in

"§0. Wolfram+AI is the quintessential team evaluating the MRB constant."

then push on keyboard.

Analyze the prototypical series for the MRB constant,

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

keys on your keyboard to move to that section.)

§1. Is that series convergent?

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

§3. Is that series absolutely convergent?

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

§5. Is there a geometric isomorphism between the many dimensions required to determine the "value" of the MRB constant to 10^34 digits (a value determined by the Planck scale),and, perhaps, the dimensions required in the prototypical problem of Graham's number?

§6. Q&A:

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

§10. How it all began,

§11. Scholarly works

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

## Second post:

"The following might help anyone serious about breaking my record."

## Third post

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

## Fourth post

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

## Many more interesting posts

... including, not to omit, Real-World and beyond, Applications which have been moved to this discussion to save on loading times.

...including the

"MRB constant supercomputer"s 1 and 2.

...including records of computing the MRB constant from

"Crandall's eta derivative formulas".

...including all the methods used to compute CMRB

"and their efficiency".

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

"decimal expansions".

...including the

"convergence rate" of 3 primary forms of CMRB.

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

...including

"arbitrarily close approximation formulas" for CMRB.

...including

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

...including a recent discovery that could

"help in verifying" digital expansions of the integrated analog (MKB) of CMRB.

...including an inquiry for a

"closed form" for CMRB.

"how normal" CMRB is, and what Google OpenAI Chat CPT says.

...including a few attempts at a

"A cool 7 million digits?"

... including an overview of all CMRB

"speed records of MRB constant", by platform.

... including

"yet another attempt at 7 million digits".

The MRB constant relates to the divergent series:

=

The sequence of its partial sums has two limit points with an upper limit point known as the MRB constant (CMRB).

So, out of the many series for CMRB, first analyze the sum prototype, i.e., the series, =

Concerning the sum prototype for CMRB

§1. Is the series convergent?

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

# 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 has a limit as n goes to infinity of zero. Of course, $\sum_1^3(-1)^n(n^{1/n}-1)$, converges, and the sum of two convergent series converges.

By utilizing the Squeeze theorem (also known as the Sandwich theorem) and plotting techniques, it has 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 has a limit of zero as n approaches infinity. Ultimately, the series $\sum_1^3(-1)^n(n^{1/n}-1)$ converges, and the sum of two convergent series is also convergent. Thus, the series is convergent. ∎

The Leibniz criterion, summoned above, is defined and proven here:

The short explanation is that $z_0$ must be real for the limit to be 0, and since $lim_{n->\infty}n^{1/n}=1,$ $z_0=1.$

Using the same limit, for a non-constant term f(n) in $\sum_{n=1}^\infty(-1)^n(n^{1/n}-f(n)), lim_{n->\infty}f(n)=1,$ As shown soon ( "As for efficiency" ).

§3.

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.

Surprisingly, both sides of all three inequalities meet at the first Foias Constant instead of e:

In

N[FindRoot[n^(1/n) - 1 - 1/n == 0, {n, .1}, WorkingPrecision -> 38], 32]


Out[58]= {n -> 2.2931662874118610315080282912508}

In

   N[ FindRoot[n == (1 + 1/n)^n, {n, 1.2}, WorkingPrecision -> 38], 32]


Out[73]= {n -> 2.2931662874118610315080282912508}

In

      N[FindRoot[n^(1/n) == (1 + 1/n), {n, 1.2}, WorkingPrecision -> 38], 32]


Out[72]= {n -> 2.2931662874118610315080282912508}

For the series of absolute values, notice $$-1<\sum_{n=1}^x\left(n^{\frac{1}{n}}-1\right)-\sqrt{x}-1<0.5$$ for $$11\leq x\leq 286$$

Analogously to the Riemann Zeta Function , , another analogy to the harmonic series on how n below, at, and above 1 affects the convergence of the series of absolute values exists,

Similarly to the Riemann Zeta Function:

For n<1, (the sum of absolute values) diverges.

For n=1, the series also diverges.

Only when n>1 does the series converge:

Assuming[n > 1,
SumConvergence[{(-1)^x (x^(1/x) - 1)/x, (x^(1/x) - 1)/
x, (-1)^x x^(1/x)/x^1, x^(1/x)/
x^1, (-1)^x x^(1/x)/x^(n) and x^(1/x)/x^(n)}, x]]


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

§5.

RABBIT HOLE #2: (a conjecture, i.e., guess, for an upper limit of Graham's number) The Geometry of the MRB constant from that sum CMRB=$\sum_{n=1}^\infty(-1)^n(n^{1/n}-1)$, Is the process that plots values from constructions arising from a peculiar non-Euclidean geometric isomorphism

between

the number of dimensions required for its partial sums (describing the length of hypercubes) to determine the "value" of the MRB constant to 10^34 digits (a value determined by the Planck scale)

and, perhaps,

the dimensions required in the prototypical problem of Graham's number

where there are the following.

From Wikipedea, Graham's number is connected to the problem in Ramsey theory:

Connect each pair of geometric vertices of an n-dimensional hypercube to obtain a complete graph on 2^n vertices. Color each of the edges of this graph either red or blue. What is the smallest value of n for which every such coloring contains at least one single-colored complete subgraph on four coplanar vertices?

Where for the Geometry of the MRB constant:

Then find a

There in Diagram 3, M, at the point of the segment is where the z=MRB constant would be, and the base of that segment is the MRB constant -1.

An isomorphism is a concept in mathematics that refers to a one-to-one correspondence or mapping between two sets, preserving the binary relationships between the elements of the sets. The question at hand is whether this term is applicable in this context.

The known convergence rate of the MRB constant sum (i.e., taking n digits from $10^{n+1}$ partial sums) implies that if an isomorphism exists, it would establish a significantly smaller upper limit for Graham's number. It is currently unknown whether the conjecture that maps dimensions for the edges of hypercubes in CMRB (alternating sums of n^(1/n)) to the dimensions required for "the smallest value of n for which every such coloring contains at least one single-colored complete subgraph on four coplanar vertices in Graham's number problem (some unknown function involving 2^n)" is a plausible one or if it is merely numerological speculation.

§6.

# Q&A:

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

A:

As you see, the war treated me kindly enough, in spite of the heavy gunfire, to allow me to get away from it all and take this walk in the land of your ideas.

— Karl Schwarzschild (1915), “Letter to Einstein”, Dec 22


Q: Can you calculate more digits of CMRB?

A:

With the availability of high-speed electronic computers, it is now quite convenient to devise statistical experiments for the purpose of estimating certain mathematical constants and functions.

Copyright © 1966 ACM
(Association for Computing Machinery)

New York, NY, United States


Q: How can you compute them?

A:

The value of $\pi$ has engaged the attention of many mathematicians and calculators from the time of Archimedes to the present day, and has been computed from so many different formulae, that a complete account of its calculation would almost amount to a history of mathematics.

—  James Glaisher (1848-1928)


Q: Why should you do it?

A:

While it is never safe to affirm that the future of Physical Science has no marvels in store even more astonishing than those of the past, it seems probable that most of the grand underlying principles have been firmly established and that further advances are to be sought chiefly in the rigorous application of these principles to all the phenomena which come under our notice. It is here that the science of measurement shows its importance — where quantitative work is more to be desired than qualitative work. An eminent physicist remarked that the future truths of physical science are to be looked for in the sixth place of decimals.

 —  Albert A. Michelson (1894)


Q: Why are those digits there?

A:

[The principle, "nothing is without reason (nihil est sine ratione), or there is no effect without a cause"] must be considered one of the greatest and most fruitful of all human knowledge, for upon it is built a great part of metaphysics, physics, and moral science. (G VII 301/L 227).

—  Gottfried Wilhelm Leibniz (1646–1716)


§7. This discussion is not crass bragging; it is an attempt by this amateur to share his discoveries with the greatest audience possible.

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

As he went more and more public with his discoveries, making several attempts to see what portions were original, he 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 has 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 him 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 his investigations in physics and geometry. He 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 its 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


\

§10.

# How it all began

From these meager beginnings: This person's life experience demonstrates that academic grades in school may not accurately predict success in mathematics. Their report cards show poor grades in the subject. However, when given a self-paced program, the person discovered a newfound interest in math in junior high. Their grades improved with the opportunity to explore as they researched and studied more. They continued to pursue their passion for math, writing out powers of 2 and creating algebra problems for themselves to solve. They even purchased introductory calculus books. Despite caring for their mother with Alzheimer's and working long hours, they attended university classes to further their knowledge. They are now listed on Wikipedia as an amateur mathematician and have studied graduate-level topics in mathematics. The reason for their slow start and eventual success is unclear and could be attributed to factors such as the educational system and psychology. However, their belief in their ability to learn and succeed in math played a crucial role in their achievements.

**From these meager beginnings: **

On January 11 and 23,1999, this pilgrim wrote,

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

The point is that the author found the MRB constant (CMRB), meaning after all the giants were through roaming the forest of numbers and founding all they found, one virgin mustard seedling caught their eye. So, this writer carefully "brought it up" to a level of maturity and my understanding of math along with it! (In another reality, I invented CMRB and then discovered many of its qualities.)

In doing so found out that this constant (CMRB)

was more closely related to other constants than could have been imagined.

As the apprentice of all, building upon the foundation of Chebyshev (1854–1859) on the best uniform approximation of functions, as vowed on January 23, 1999. "I took CMRB apart and examined it 'bit by bit,' finding connections to all kinds of arithmetical manipulations." Not satisfied with all too convenient constructs (half-hazardously put together formulas) that a naïve use of numeric search engines like Wolfram Alpha or the OEIS might give, this researcher set out to determine the most interesting (by being the most improbable but true) approximations for each constant in relation to it.

For example, consider α=the fine structure constant, arguably the most fundamental constant of all, with a value that nearly equals 1/137. Or 1/137.03599913= 0.00729735257..., to be precise, and essentially and metaphorically equals (-133+60*10^(2/5))CMRB/456 . It is denoted by the Greek letter alpha – α. Let m be the MRB constant. Then we have

We have a strong arithmetic relationship with the Lemniscate Constant:

According to Wikipedia

In mathematics, the lemniscate constant ϖ is a transcendental mathematical constant that is the ratio of the perimeter of Bernoulli's lemniscate to its diameter, analogous to the definition of π for the circle.

Consider its relationship to Viswanath's constant (VC)

With both being functions of x1/x alone, ** we have these near-zeors of VC using C*MRB*, which have a ratio of Gelfond's constant $=e^\pi.$

Then there is the Rogers - Ramanujan Continued Fraction, R(q),

of CMRB that is well-linearly approximated by terms of other terms of CMRB alone:

What about "?" for m= the MRB constant?

From these meager beginnings:

On Feb 22, 2009, this pilgrim wrote,

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

Come to find out this discovery, a very slow-to-converge oscillatory integral, would later be further defined by Google Scholar.

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

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

Which is the same as

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

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

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

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

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

M1 has a convergent series, which has lines of symmetry across whole-and-half number points on the x-axis, and half-periods of exactly 1, for both real and imaginary parts as in the following plots.

ReImPlot[(-1)^x (x^(1/x) - 1), {x, 1, Infinity}, PlotStyle -> Blue,
Filling -> Axis, FillingStyle -> {Green, Red}]


Also where

Then

f[x_] = Exp[I Pi x] (x^(1/x) - 1); Assuming[
x \[Element] Integers && x > 1,
FullSimplify[Re[f[x + 1/2]] - Im[f[x]]]]


gives 0

## In the complex plane, they even converge at the same rate.

Every 75 i of the upper value of the partial integration yields 100 additional digits of M2= and of CMRB==

Here is a heuristic explanation for the observed behavior.

Write the integral as an infinite series, $m= \sum_{k = 1}^\infty a_k$ with $a_k = \int_{i kM}^{i (k+1)M} \frac{t^{1/t}-1}{\sin (\pi t)} \, dt$ for $k \ge 2$ and the obvious modification for $k = 1$. we are computing the partial sums of these series with $M = 75$ and the question is why the series remainders decrease by a factor of $10^{-100}$ for each additional term.

The integrand is a quotient with numerator $t^{1/t} - 1 \approx \log t\, / t$ and denominator $1/\sin \pi t \approx e^{i \pi t}$ for large imaginary $t$. The absolute values of these terms therefore are $|a_k| \approx \log |kM|/|kM| \cdot e^{-\pi kM}$. This implies:

as $k \to \infty$. Consequently, the remainders $\sum_{k = N}^\infty$ behave like $e^{- \pi N M}$. They decrease by a factor of $e^{-\pi M}$ for each additional term. And for $M = 75$, this is approximately $10^{-100}$, predicting an increase in accuracy of 100 digits whenever the upper integration bound increased by $75i$.

I used the fact that

The following "partial proof of it" is from Quora.

While

A lot more theory behind it and ways of computing many more digits in this linked Wolfram Community post.

From these meager beginnings:

In October 2016, his pilgrim wrote the following here in researchgate:

First, we will follow the path the author took to find out that, for


,

the limit of the ratio of a to a - 1, as a goes to infinity, is Gelfond's Constant, (e ^ pi). We will consider the hypothesis and provide hints for proof using L’ Hospital’s Rule (since we have indeterminate forms as a goes to infinity):

The following should help in proving the hypothesis:

Cos[PiIx] == Cosh[Pix], Sin[PiIx] == I Sin-h[Pix], and Limit[x^(1/x),x->Infinity]==1.

Using L’Hospital’s Rule, we have the following:

(17) (PDF) Gelfond's Constant using MKB-constant-like integrals. Available from: https://www.researchgate.net/publication/309187705Gelfond%27sConstantusingMKBconstantlikeintegrals [accessed Aug 16 2022].

We find no limit "a" goes to infinity of the ratio of the previous forms of integrals when the "I" is left out, and we give a small proof for their divergence.

That was responsible for the integral-equation-discovery mentioned in one of the following posts, where it is written, "Using those ratios, it looks like" (There is the MRB constant.)

From these meager beginnings:

In November 2013, his pilgrim wrote:

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

$\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-a)$ is formally convergent only when $a =1$. However, if you extend the meaning of $\sum$ through "summation methods", whereby series that diverge in one sense converge in another sense (e.g., Cesaro, etc.), you get results for other $a$. A few years ago, it came to this author to ask what value of $a$ gives $$\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-a)=0\text{ ?}$$(For what value of a is the Levin's u-transform's and Cesàro's sum result 0 considering weak convergence?)

It was $a=1-2\times C\mathrm{MRB}=0.6242807150758657595029641318914535398881938101997224\ldots$.

I asked, "If that's correct can you explain why?" and got the following comment.

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

See here.

Also,

§11.

From these meager beginnings:

In 2015 his pilgrim wrote:

Mathematica makes some attempts to project hyper-dimensions onto 2-space with the Hypercube command. Likewise, some attempts at tying them to our universe are mentioned at https://bctp.berkeley.edu/extraD.html . The MRB constant from infinite-dimensional space is described at http://marvinrayburns.com/ThegeometryV12.pdf. It is my theory that like the MRB constant, the universe, under inflation, started in an infinite number of space dimensions. They almost all instantly collapsed, leaving all but the few we enjoy today.

This is not the first time for one to think the universe consists of an infinitude of dimensions. Some string theories and theorists propose it too. Michele Nardelli added a vast amount of string theory analysis and its connection to dimensions and the MRB constant.

He said,

In the following links, there are several works concerning various sectors of Theoretical Physics, Cosmology, and Applied Mathematics, in which MRB Constant is used as a "regularizer" or "normalizer". This constant allows to obtain a better approximation to the solutions obtained, developing the various equations that are analyzed. The solutions in turn, lead to four numbers that are called "recurring numbers". They are zeta (2) = Pi^2/6, 1729 (Hardy-Ramanujan number), 4096 (which multiplied by 2 gives the gauge group SO (8192)) and the Golden Ratio 1.61803398 ...

HE HAS PUBLISHED HUNDREDS OF PAPERS ON STRING THEORY AND THE MRB CONSTANT!

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

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

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

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

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

§12.

# MRB Constant Records,

Google OpenAI 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][195]   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

 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

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.


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. ![CTRL+f][202]  "4th of July, 2022" for documentation.
To beat that, on the 7th of July, 2022, the same digits in  1/5 of an hour. ![CTRL+f][203]  "7th of July, 2022" for documentation (850 times as fast as the first 100,000 run!)


 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 30.5 hours of absolute time and 15.7 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.  36.7 hours million notebook 30.5 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, The MRB constant supercomputer said, Finished on Wed 16 Mar 2022 02: 02: 10. computation and absolute time were 6.26628*10^6 and 1.60264035419592*10^7s respectively Enter MRB1 to print 6532491 digits. The error from a 6, 000, 000 or more digit the calculation that used a different method is 0.*10^-6029992. "Computation time" 72.526 days. "Absolute time" 185.491 days.  63 Replies Sort By: Posted 15 days ago ## §0. Wolfram+AI is the quintessential team evaluating the MRB constant. ## (CC) BingAI should have said, 2^(1/2) - 1 = 0.4142135. Instead, it calculated (1/2)^(1/2) - 1 = -1 + 1/Sqrt[2]=-0.292893 . Compare GPT with Bing in recognizing the MRB constant. Compare GPT with Bing in writing Mathematica code. : It showed "N[MRB[100], 100]" Now, it's Bing AI's turn. With just a little tweaking and a lot of automating, the program says, It takes around 10^(n+/-0.2) partial sums s for n digits. After receiving Wikipedia's and MathWorld's articles on the MRB constant (the upper limit point of the sequence of the above partial sums), Google OpenAI Chat CPT described the constant as follows. ... Burns: Write a Wikipedia article for the MRB constant. I'm sorry, as an AI language model, I cannot create or modify articles on Wikipedia. However, I can provide a draft of an article on the MRB constant that you can use as a starting point: References: • Burns, M. R. "An Alternating Series Involving n^(th) Roots." Unpublished note, 1999. • Burns, M. R. "Try to Beat These MRB Constant Records!" • http://community.wolfram.com/groups/-/m/t/366628. • Crandall, R. E. "Unified Algorithms for Polylogarithm, L-Series, and Zeta Variants." 2012a. • http://www.marvinrayburns.com/UniversalTOC25.pdf. • Crandall, R. E. "The MRB Constant." §7.5 in Algorithmic Reflections: Selected Works. PSI Press, pp. 28-29, 2012b. • Finch, S. R. Mathematical Constants. Cambridge, England: Cambridge University Press, p. 450, 2003. • Plouffe, S. "MRB Constant." http://pi.lacim.uqam.ca/piDATA/mrburns.txt. • Sloane, N. J. A. Sequences A037077 in "The On-Line Encyclopedia of Integer Sequences." Posted 1 month ago  If, above this, if you see the number of views, you will need to refresh the page in order to see the first post.As I'm retiring to spend all my time tutoring, I mentioned the following before but became uncertain of the benefit for the Community Discussion Board. I still think that if someone would like to continue working on MRB constant records with Mathematica, (or a lower-level language for comparison's sake) it would be worthy of using this space!I'm selling the latest version of the MRB constant supercomputer.MRB constant Supercomputer. An amazing combination of 12th and 13th Gen K's and KS's that was built to set the records for calculating records of number of digits of the MRB constant. See all the records at Wolfram Community\'s most visited post: Try to beat these MRB constant records! - Online Technical Discussion Groups—Wolfram Community If you would like, I will show you how to use it as a real supercomputer (faster than many severs are) with the Wolfram Lightweight grid. The buy, search "MRB constant supercomputer" in EBAY. Posted 2 months ago  Remembering that the integrated analog of the MRB constant is These results are from the Timing[] command:The i9-12900KS column is documented here. 2022 results documentation:The i9-13900K column documentation:While the i-13900K worked on the 40,000 digits of M2, the processor's speed was close to 6GHz: As mentioned somewhere above, the RAM speed is 4800MHz: [5]: https://www.wolframcloud.com/obj/bmmmburns/Published/late 2022 MKB(1).nb Posted 3 months ago yet another attempt at 7 million digits # Christmas 2022, I decided to take advantage of this cold winter and start another attempt at computing 7 million digits of the MRB constant. This time using an i9-12900KS and an i9-13900K under the auspices of the Wolfram Lightweight Grid V 11.3. Here is the rundown. I entered the following code developed over a period of 10 whole years. Print["Start time is ", ds = DateString[], "."]; prec = 7000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = 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[MRB7 = 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[ MRB7]], " digits. The error from a 5,000,000 or more digit \ calculation that used a different method is "]; N[MRB7 - MRB1, 20]  The computer said, Start time is Tue 20 Dec 2022 10:58:42. Iterations required: 9286198 I will give 4535 time estimates, each more accurate than the previous. Will stop at 9287680 iterations to ensure the precision of around 7034999 decimal places.  ... As of Sun 25 Dec 2022 09:48:13 there were 409600 iterations done in 4.2777*10^5 seconds. That is 0.95752 iterations/s. 4.410143% complete. It should take 112.247 days or 9.698*10^6s, and finish Tue 11 Apr 2023 16:54:43.  ## UPDATE The connection between my computers went out. Here is the last output. As of Mon 26 Dec 2022 18:53:42 there were 520192 iterations done in 5.4690*10^5 seconds. That is 0.95116 iterations/s. 5.600882% complete. It should take 112.997 days or 9.763*10^6s, and finish Wed 12 Apr 2023 10:54:55. ToBoxes[Refresh[InternalMessageMenu["LinkObject", "linkd", 2, 14, 1, 18551661645271640249, "Local"], None], StandardForm]LinkObject::linkd: Unable to communicate with closed link LinkObject[50018@192.168.1.227,50019@192.168.1.227,457,12]  . I'm trying to figure out the best thing to do now, so stay tuned. I'm at it again (with just one node this time, but with the same code). . For my newest attempt at 7 million digits, the latest result: As of Tue 3 Jan 2023 06:14:54 there were 432128 iterations done in 5.940310^5 seconds. That is 0.72745 iterations/s. 4.652701% complete. It should take 147.748 days or 1.27710^7s, and finish Wed 24 May 2023 03:10:57. Posted 4 months ago ## July 9, 2022 The new 16-core computer's computations with verification are documented in this notebook. Although I'm not making any large number of digits computations, I'm still working on speed records of MRB constant (CMRB) computations: However, all the following timings are absolute! From the first post, ## 01/08/2019 Here is an update of 100k digits (in seconds): Notice, I broke the 1,000-second mark!!!!! ## 4th of July, 2022 I did it in 861 seconds of absolute time! with the full power of the MRB constant supercomputer 3 (MRBSC 3). See notebook. ## 7th of July, 2022 I did it in 691 seconds of absolute time! See notebook. ## 30th of July, 2022 I did it in 682 seconds of absolute time! ## 11/27/2022 Using only 8 kernels of i9-13900K128 GB 5200MHZ RAM, only 8 kernels of i9-12900KS 64 GB 4800 MHz and only 8 kernels of i9-12900K 128 GB 5200MHZ RAM on the Wolfram Lightweight Grid, I calculated 100,493 digits of CMRB in 626.7164761s (less than 10.5 min) absolute time! And a computation time from the Timing[] command of 201.016 s (3.35 min). See the notebook here. It ends with 131072 iterations done in 626.7 seconds. Should take 0.007341 days or 634.3s, finish Sun 27 Nov 2022 14:22:31. Finished on Sun 27 Nov 2022 14:22:24. Processor time was 201.016 s. Actual time was 626.7164761 Enter MRBtest2 to print 100493 digits If you saved m3M, the difference between this and 3,014,991 known digits is 0.*10^-100494 ## 11/16/2022 I've found ways of tweaking out new records with my computers. Here is a table of several of my speed records from my fastest computers. First a caveat, there is a discrepancy in my timings in the first of the following 2 tables: The timings at and before " 3.2 GH 6core,1666 MH RAM " were absolute timings. However, it was getting too hard to commit modern computers to just the one task of computing digits -- they are doing too many other things. So, I started recording computation time from the Timing[...]. command. However, with my new i9-13900K, this Timing[..] has led to a new problem! Timing[..] does not work well with the 9-13900K's 16 efficiency cores. Naturally, I got around that issue by doing single core operations for m2 computations. Also, computations of only a few digits of CMRB have small errors (I presume). Using the Wolfram Lightweight Grid, the 300,000-digit computation used 8 cores from the I-12900KS for efficiency. This is the fairest comparison of my fastest computer's timing 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  Posted 4 months ago  Real-World, and beyond, Applications have been moved to this discussion to save on loading times. Posted 4 months ago ## How about a cool 7 million digits? . . From the MRB constant supercomputer, using only one node: In[4]:= Needs["SubKernelsLocalKernels"] Block[{$mathkernel = $mathkernel <> " -threadpriority=2"}, LaunchKernels[]] Out[5]= {"KernelObject"[1, "local"], "KernelObject"[2, "local"], "KernelObject"[3, "local"], "KernelObject"[4, "local"], "KernelObject"[5, "local"], "KernelObject"[6, "local"], "KernelObject"[7, "local"], "KernelObject"[8, "local"], "KernelObject"[9, "local"], "KernelObject"[10, "local"]} In[6]:= Print["Start time is ", ds = DateString[], "."]; prec = 7000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, 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[MRB7 = 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[MRB7 - MRB1, 20] During evaluation of In[6]:= Start time is Thu 14 Apr 2022 16:22:41. During evaluation of In[6]:= Iterations required: 9286198 During evaluation of In[6]:= Will give 4535 time estimates, each more accurate than the previous. During evaluation of In[6]:= Will stop at 9287680 iterations to ensure the precision of around 7034999 decimal places.  ...  As of Sun 12 Jun 2022 02:23:15 there were 2600960 iterations done in 5.0472*10^6 seconds. That is 0.51532 iterations/s. 28.00441% complete. It should take 208.566 days or 1.802*10^7s, and finish Wed 9 Nov 2022 05:58:01.  ... For an unknown reason, the computer restarted on June 16, 2022. Since the 3/4 of the MRB constant supercomputer using my 4th-degree convergence rate algorithm is so efficient, I decided to use then to confirm the 7 million being computed by the other fourth using a hybrid algorithm. The 4th-degree convergence rate calculation will get done sooner than the one that started a few months earlier! Here are the codes and results in the same form as the hybrid one shown in a few messages above that starts with, "How about a cool 7 million digits?". In[3]:= CloseKernels[] In[1]:= Needs["SubKernelsLocalKernels"] 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"[14, "local"], "KernelObject"[15, "local"], "KernelObject"[16, "local"], "KernelObject"[17, "WIN-1AA39U1LQNT"], "KernelObject"[18, "WIN-1AA39U1LQNT"], "KernelObject"[19, "WIN-1AA39U1LQNT"], "KernelObject"[20, "WIN-1AA39U1LQNT"], "KernelObject"[21, "WIN-1AA39U1LQNT"], "KernelObject"[22, "WIN-1AA39U1LQNT"], "KernelObject"[23, "WIN-1AA39U1LQNT"], "KernelObject"[24, "WIN-1AA39U1LQNT"], "KernelObject"[25, "WIN-1AA39U1LQNT"], "KernelObject"[26, "WIN-1AA39U1LQNT"], "KernelObject"[27, "WIN-1AA39U1LQNT"], "KernelObject"[28, "WIN-1AA39U1LQNT"], "KernelObject"[29, "WIN-1AA39U1LQNT"], "KernelObject"[30, "WIN-1AA39U1LQNT"], "KernelObject"[31, "WIN-1AA39U1LQNT"], "KernelObject"[32, "WIN-1AA39U1LQNT"], "KernelObject"[33, "2600:1700:71d0:fd50:0:0:0:12"], "KernelObject"[34, "2600:1700:71d0:fd50:0:0:0:12"], "KernelObject"[35, "2600:1700:71d0:fd50:0:0:0:12"], "KernelObject"[36, "2600:1700:71d0:fd50:0:0:0:12"], "KernelObject"[37, "2600:1700:71d0:fd50:0:0:0:12"], "KernelObject"[38, "2600:1700:71d0:fd50:0:0:0:12"]} In[3]:= Print["Start time is ", ds = DateString[], "."]; prec = 7000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = pr/2^6; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[4 pc, pr]; x = SetPrecision[x, pc]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pc] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, 2 pc] ll (ll - 1)/(3 ll t2 + t^3 z))];(**N[Exp[Log[ll]/ ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc, " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[ MRB1]], " digits. The error from a 6,500,000 or more digit calculation that used a different method is "]; N[MRB - MRB1, 20] Start time is Fri 10 Jun 2022 09:19:40. Iterations required: 9286198 Will give 4535 time estimates, each more accurate than the previous. Will stop at 9287680 iterations to ensure precsion of around 7034999 decimal places. As of Fri 10 Jun 2022 10:23:46 there were 2048 iterations done in 3846.5 seconds. That is 0.53243 iterations/s. 0.02205072% complete. It should take 201.865 days or 1.744*10^7s, and finish Thu 29 Dec 2022 06:04:33.  ## ... As of Mon 20 Jun 2022 09:53:03 there were 780288 iterations done in 8.6600*10^5 seconds. That is 0.90102 iterations/s. 8.401323% complete. It should take 119.286 days or 1.031*10^7s, and finish Fri 7 Oct 2022 16:11:11.  ## ... Thinking that it would be more productive to explore the power of the full MRB constant supercomputer 3 than to run this computation for 3 and a half more months, I am going to stop this computation. I've shown that the 7,000,00 digits could be done in around120 days with these resources. 6/27/2022 With my network, the digit calculations of 1,000,000 or less are not to be improved by the additional 1/4 of the MRBSC3. To conserve energy, I'm waiting until the outdoor temperature is likely to stay under 90° F, here in Indianapolis, for a few months before I do any more large calculations. # I'm at it again! The third attempt at a spectacular 7 million digits using Mathematica 13.1 with 8 kernels on 8 performance and 8 efficiency cores at 5.2 GHz with 60000 Mhz DDR5 memory (under-clocked to 4000MHz), using an algorithm with a 4th-degree convergence rate. Start time is Sun 10 Jul 2022 05:04:03. Iterations required: 9286198 Will give 4535 time estimates, each more accurate than the previous. Will stop at 9287680 iterations to ensure precsion of around 7034999 decimal places. As of Sun 10 Jul 2022 06:51:13 there were 2048 iterations done in 6429.7 seconds. That is 0.31852 iterations/s. 0.02205072% complete. It should take 337.432 days or 2.915*10^7s, and finish Mon 12 Jun 2023 15:26:08.  ... As of Tue 19 Jul 2022 02:56:38 there were 452608 iterations done in 7.6995*10^5 seconds. That is 0.58784 iterations/s. 4.873208% complete. It should take 182.838 days or 1.580*10^7s, and finish Mon 9 Jan 2023 01:11:14.  I'm getting fast at computing a potential 7 million digits of CMRB. See my latest attempt, where I had a crash. I'll try this again soon! I'm off to the best start of 7,000,000 digits yet! Start time is Thu 25 Aug 2022 19:27:24. Iterations required: 9286198 Will give 4535 time estimates, each more accurate than the previous. Will stop at 9287680 iterations to ensure precsion of around 7034999 decimal places. As of Thu 25 Aug 2022 20:20:52 there were 2048 iterations done in 3208.0 seconds. That is 0.63841 iterations/s. 0.02205072% complete. It should take 168.354 days or 1.455*10^7s, and finish Fri 10 Feb 2023 03:57:26.  ...  As of Sun 4 Sep 2022 19:15:45 there were 968704 iterations done in 8.6330*10^5 seconds. That is 1.1221 iterations/s. 10.42999% complete. It should take 95.7845 days or 8.276*10^6s, and finish Tue 29 Nov 2022 14:17:08.  You probably expected this. I started another 7,000,00-digit computation, this time using an i9-12900KS (16 core all at 5.5 GHz) computer with 4800 MHz. Here is one of the first results Here is the latest result: Posted 6 months ago  Along the lines of how normal the MRB constant is, I noticed the following about its original sum,$\displaystyle{\sum_{n=1}^{\infty}(-1)^n(n^{1/n}-1)}.$I wondered, (what would happen to the sum if you added smaller and smaller steps?)  ReImPlot[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/n}, WorkingPrecision -> 30, Method ->"AlternatingSigns"], {n, 1, Infinity}]   In[35]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^20}, WorkingPrecision -> 70, Method -> "AlternatingSigns", NSumTerms -> 2000]] Out[35]= -1.\ 999999749999999973333339999999998228052447182132376098872359604490555*\ 10^-14 In[36]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^30}, WorkingPrecision -> 70, Method -> "AlternatingSigns", NSumTerms -> 2000]] Out[36]= -1.\ 999999749999999999999999997333333999999999999999999982280524444387501*\ 10^-24 In[37]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^40}, WorkingPrecision -> 70, Method -> "AlternatingSigns", NSumTerms -> 2000]] Out[37]= -1.\ 999999749999999999999999999999999999733333399999999999999990562538808*\ 10^-34 In[38]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^50}, WorkingPrecision -> 70, Method -> "AlternatingSigns", NSumTerms -> 2000]] Out[38]= -1.\ 999999749999999999999999999999999999999999999973243568040505517332039*\ 10^-44 In this case, finding exactly where the error starts is difficult for me. But let's assume the following is true. In[5]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^30}, WorkingPrecision -> 40, Method -> "AlternatingSigns"]] Out[5]= -1.12250000000000000000000000002637761741*10^-28 In[6]:= Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 2/10^40}, WorkingPrecision -> 50, Method -> "AlternatingSigns"]] Out[6]= -2.244999999999999999999999999999999999982964553611*10^-38  In[39]:= p = Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^200}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]] Out[39]= \ -1.1224999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999887999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999951865743238994910613\ ...*10^-198In[41]:= Rationalize[N[Q100 = 10^98 p + 1, 200], 0]] $$\frac{8908685968819599109131403118040089086859688195991091314031180400890868596881959910913140311804008907}{8908685968819599109131403118040089086859688195991091314031180400890868596881959910913140311804008908}$$I think it's worth pointing out that the rational approximation consists, entirely, of repeating $$89086859688195991091314031180400's$$ except for the last digit of the numerator.Some steps of multiples of powers of 10 also give solutions with many repeating 9s. In[59]:= N[ Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 100] Out[59]=-1.122499999999999999999999999999999999998879999999999999999999999999999999999995186574323899491061367*10^-38 In[54]:= N[Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/20^40}, WorkingPrecision -> 1000, Method ->"AlternatingSigns"]], 55] Out[54]= \ -1.020907802740111947059631347656249999999999999999999074*10^-50 In[69]:= N[Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/50^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 150] Out[69]= \ -1.2342018021785599999999999999999999999999999999999999999999999999998\ 6460030820316153243290828799999999999999999999999999999999999999993601\ 859835697267*10^-66 In[84]:= N[ Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/200^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 200] Out[84]= \ -1.0209078027401119470596313476562499999999999999999999999999999999999\ 9999999999999999999999990735577139406090041440222648816416040062904357\ 91015624999999999999999999999999999999999999637878099817017722*10^-90I posted it at https://math.stackexchange.com/questions/4575530/sum-infty-textstylex-11-k-atopk-in-1-ldots-infty-1x-x1 to see if anyone can explain it.I found the following that shows a little bit of what happens for smaller and smaller steps of powers 2 and 5, which are related to powers 10.By a factor of pi, the imaginary part has at least as many repetitions of decimals.In N[Table[Im[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^n}, WorkingPrecision -> 180, Method -> "AlternatingSigns"]], {n, 20, 50}], 100]/Pi Out[216]= \ {-1.014999999999999999889749999999999999985380680380635051103404220561\ 131468438815891294117640691851961*10^-37, \ -1.0149999999999999999889749999999999999998538068038063505110089362727\ 15953551936726556669955860834527*10^-39, \ -1.0149999999999999999988974999999999999999985380680380635051100642567\ 94264174386914539123932192756267*10^-41, \ -1.0149999999999999999998897499999999999999999853806803806350511006174\ 62009746382736692535387904947180*10^-43, \ -1.0149999999999999999999889749999999999999999998538068038063505110061\ 49514164568466234472485086767530*10^-45, \ -1.0149999999999999999999988974999999999999999999985380680380635051100\ 61470035712789301212271980781307*10^-47, \ -1.0149999999999999999999998897499999999999999999999853806803806350511\ 00614675251194997650990266937597*10^-49, \ -1.0149999999999999999999999889749999999999999999999998538068038063505\ 11006146727406017081148770216506*10^-51, \ -1.0149999999999999999999999988974999999999999999999999985380680380635\ 05110061467248954237916126569712*10^-53, \ -1.0149999999999999999999999998897499999999999999999999999853806803806\ 35051100614672464436446265904565*10^-55, \ -1.0149999999999999999999999999889749999999999999999999999998538068038\ 06350511006146724619258529763685*10^-57, \ -1.0149999999999999999999999999988974999999999999999999999999985380680\ 38063505110061467246167479364741*10^-59, \ -1.0149999999999999999999999999998897499999999999999999999999999853806\ 80380635051100614672461649687715*10^-61, \ -1.0149999999999999999999999999999889749999999999999999999999999998538\ 06803806350511006146724616471771*10^-63, \ -1.0149999999999999999999999999999988974999999999999999999999999999985\ 38068038063505110061467246164693*10^-65, \ -1.0149999999999999999999999999999998897499999999999999999999999999999\ 85380680380635051100614672461647*10^-67, \ -1.0149999999999999999999999999999999889749999999999999999999999999999\ 99853806803806350511006146724616*10^-69, \ -1.0149999999999999999999999999999999988974999999999999999999999999999\ 99998538068038063505110061467246*10^-71, \ -1.0149999999999999999999999999999999998897499999999999999999999999999\ 99999985380680380635051100614672*10^-73, \ -1.0149999999999999999999999999999999999889749999999999999999999999999\ 99999999853806803806350511006147*10^-75, \ -1.0149999999999999999999999999999999999988974999999999999999999999999\ 99999999998538068038063505110061*10^-77, \ -1.0149999999999999999999999999999999999998897499999999999999999999999\ 99999999999985380680380635051101*10^-79, \ -1.0149999999999999999999999999999999999999889749999999999999999999999\ 99999999999999853806803806350511*10^-81, \ -1.0149999999999999999999999999999999999999988974999999999999999999999\ 99999999999999998538068038063505*10^-83, \ -1.0149999999999999999999999999999999999999998897499999999999999999999\ 99999999999999999985380680380635*10^-85, \ -1.0149999999999999999999999999999999999999999889749999999999999999999\ 99999999999999999999853806803806*10^-87, \ -1.0149999999999999999999999999999999999999999988974999999999999999999\ 99999999999999999999998538068038*10^-89, \ -1.0149999999999999999999999999999999999999999998897499999999999999999\ 99999999999999999999999985380680*10^-91, \ -1.0149999999999999999999999999999999999999999999889749999999999999999\ 99999999999999999999999999853807*10^-93, \ -1.0149999999999999999999999999999999999999999999988974999999999999999\ 99999999999999999999999999998538*10^-95, \ -1.0149999999999999999999999999999999999999999999998897499999999999999\ 99999999999999999999999999999985*10^-97}  Posted 6 months ago  ...including a question about how normal CMRB is and what Google OpenAI Chat CPT said, It also added, The fact that the limit of k^(1/k) as k approaches infinity is 1 and the limit of Sum[(-1)^kk^(1/k),{k,1,n}] as n approaches infinity is 0.187859... does not necessarily mean that the MRB constant is a normal number. The MRB constant (CMRB) can be compared to the constant$\pi$in terms of how normal of a number it is: here.Example, where CMRB has an normality number of 0, perfectly normal in base 5 for 50 digits. Posted 6 months ago  Here is an answer to the previous question.While mathematicians try to crack this nut, here's a physicist's point of view. I will focus on how to calculate this integral, keeping things as simple as possible, probably approximately.The imaginary part of$(1+it)^{\frac{1}{1+it}}$: $$f(t)=(1+t^2)^{\frac{1}{2(1+t^2)}}e^{\frac{t\arctan t}{1+t^2}}\sin\left [\frac{\arctan t}{1+t^2}-\frac{t\ln(1+t^2)}{2(1+t^2)} \right ]$$Such a gem divided by$\sinh(\pi t)$needs to be integrated from zero to infinity in so-called closed form.For a physicist, this is a hopeless case. But...Some of the first terms of Taylor's expansion of$f(t)$: $$t-\frac{t^3}{2}-\frac{3t^5}{4}+...$$Indeed, this expansion diverges for$1
Posted 7 months ago
 At Concerning CMRB==, I asked the following.For some insight, I looked at comments by @Brevan Ellefsen, but still wonder if this integral can be expressed more elementarily than just calling it $C_{MRB},$ which is short for the MRB constant which I first described as a sum at the end of the last millennium. There is no known closed-form expression of the MRB constant. With as slow as the series is to converge and as hard the integral is to calculate, a finite number of standard operations for the constant would be just glorious! Here is a summary of nearly a quarter century of evaluating it.@Dark Malthorp had the insight to prove my suspicion as shown: " "Is it possible to use a residue calculation to find a closed form for $$C{MRB} = \int0^\infty \frac{\Im(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}dt?$$I'm not sure if I'm on the right track, but $\frac{(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}$ having a pole at $0,$ can we consider the possibility of evaluating $$2C_{MRB} = \int_{-\infty}^\infty \frac{\Im(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}dt?$$ I found out Mathematica gives the following. In[70]:= Limit[Im[(1 + I t)^(1/(1 + I t)) Csch[\[Pi] t]], t -> 0] Out[70]= 1/\[Pi] In[181]:= Residue[(1 + I t)^((1/(1 + I t))) /Sinh[\[Pi] t], {t, 0}] Out[181]= 1/\[Pi] In[236]:= NIntegrate[ Im[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]], {t, 0, Infinity}] Out[236]= 0.18786 In[237]:= 1/2 - 1./Pi Out[237]= 0.18169 This line of reasoning gives a nice set of approximations for CMRB, but nothing exact. In[527]:= CMRB=NSum[(-1)^n (n^(1/n)-1), {n,1,Infinity},WorkingPrecision->30,Method->"AlternatingSigns"] Out[527]= 0.18785964246206712024857897184 Let p be the following partial approximation In[544]:= p=((1/2-1/\[Pi])+1/(2 \[Pi]-1)); In[545]:= CMRB - 1/2 p Out[545]= 0.00237470999999980600500193334 In[546]:= (-279/(485 \[Pi]) + p) - CMRB Out[546]= -7.2407186775943961640*10^-10 In[547]:= (237471/50000000 + p)/2 - CMRB Out[547]= 1.9399499806666*10^-16 In[548]:= (Pi^2 Sqrt[4187/10993830] + p)/3 - CMRB Out[548]= 3.1221252470091*10^-16  A different line of reasoning follows, but its analysis, or how to improve its approximation (or even to determine whether that approximation is fully related to it) is beyond my power.Here is a little more detail showing some symmetry, but I don't see anything exactly equaling CMRB here. In CMRB/2 + NIntegrate[ E/Pi t - Im[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]]/ Re[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]], {t, 0, a}, WorkingPrecision -> 20] - (3078 p)/(7769 p + 3850) Out[827]= 1.714*10^-19
Posted 11 months ago
 A reply a couple of places before this one has some "Programs to compute the integrated analog". Here is a recent discovery that could help in verifying the analog's digital expansions.When f[x_] = E^(I Pi x) (1 - (1 + x)^(1/(1 + x))), the MRB constant is Sum[f[n],{n,0,Infinity}] and also, Sum[f[n],{n,1,Infinity}].
Posted 1 year ago

# Programs to compute the integrated analog

## The efficient programs

Wed 29 Jul 2015 11:40:10

From an initial accuracy of only 7 digits,

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


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

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


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

Attachments:
Posted 1 year ago

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

The MRB constant supercomputer said,

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

"Processor time" 72.526 days

"Actual time" 185.491 days

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

Attachments:
Posted 1 year ago
 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 views8: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 (precisely nine years). That's an average of 211.5 views/hour, or one view every 17 seconds.
Posted 1 year 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 1 year ago

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

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

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

In[4]:= Print["Start time is ", ds = DateString[], "."];
prec = 6500000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
n = Floor[1.32 pr];
end = Ceiling[n/chunksize];
Print["Iterations required: ", n];
Print["Will give ", end,
" time estimates, each more accurate than the previous."];
Print["Will stop at ", end*chunksize,
" iterations to ensure precsion of around ", pr,
" decimal places."]; d = ChebyshevT[n, 3];
{b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
iprec = Ceiling[pr/396288];
Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];
pc = iprec;
While[pc < pr/65536, pc = Min[3 pc, pr/65536];
x = SetPrecision[x, pc];
y = x^ll - ll;
x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];
(**N[Exp[Log[ll]/ll],pr/99072]**)
x = SetPrecision[x, pr/16384];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/16384] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/16384] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
ll]/ll],pr/4096]*)x = SetPrecision[x, pr/4096];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/4096] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/4096] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
ll]/ll],pr/4096]*)x = SetPrecision[x, pr/1024];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
ll]/ll],pr/1024]*)x = SetPrecision[x, pr/256];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
ll]/ll],pr/256]*)x = SetPrecision[x, pr/64];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/64]**)x = SetPrecision[x, pr/16];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/16]**)x = SetPrecision[x, pr/4];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/4]**)x = SetPrecision[x, pr];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/
ll],pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}], Method -> "Automatic"];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
If[kc > 1,
Print["As of  ", DateString[], " there were ", kc,
" iterations done in ", N[st, 5], " seconds. That is ",
N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7],
"% complete.", " It should take ", N[ti, 6], " days or ",
N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]];
Print[];, {k, 0, end - 1}];
N[-s/d, pr]];
t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ",
DateString[], ". Proccessor and actual time were ", t2[[1]], " and ",
SessionTime[] - T0, " s. respectively"];
Print["Enter MRB1 to print ",
Floor[Precision[
MRB1]], " digits. The error from a 5,000,000 or more digit \
calculation that used a different method is  "]; N[M6M - MRB1, 20]

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

Iterations required: 8622898

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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


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

Here a recent update:

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


A few days later,

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


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

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


The MRB constant supercomputer just said,

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


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

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

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

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

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

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

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

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

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


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

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

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

...


## Last update for 2021

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


## 2022 results

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

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

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

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

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

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

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

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

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

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

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

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

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


Probably my last update:

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


**

## Less than 26 hours until completion!

**

Posted 1 year ago

# WOW!!!!

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

Maybe a few more restrictions, like a≠b.

See cloud notebook.

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

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

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

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

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

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

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

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

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

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

Posted 2 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...nb." Print["Start time is ", ds = DateString[], "."]; prec = 6000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/396288]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; (**N[Exp[Log[ll]/ll],pr/396288]**) pc = iprec; While[pc < pr/65536, pc = Min[3 pc, pr/65536]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/65536]**) x = SetPrecision[x, pr/16384]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16384] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16384] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr/16384]*) x = SetPrecision[x, pr/4096]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4096] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4096] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr/4096]*) x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) -SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ ll]/ll],pr/1024]*) x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ ll]/ll],pr/256]*) x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ ll]/ll],pr/64]**) x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ ll]/ll],pr/16]**) x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (**N[Exp[Log[ll]/ll],pr/4]**) x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z)); (*N[Exp[Log[ll]/ll],pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc, " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[ MRB1]], " digits. The error from a 5,000,000 or more digit \ calculation that used a different method is "]; N[MRB - MRB1, 20] The 5,500,000+digit run is found below in the attached "5p5million.nb," including the verified 5,609,880 digits. (*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 5500000;(*Number \ of required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; (*N[Exp[Log[ll]/ll], pr/27]*) pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (*N[Exp[Log[ll]/ll], pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; N[MRBtest2 - MRB, 20]  Attachments:
Posted 2 years ago
 The MRB constant supercomputer 2 is still working on 6,500,000 and 5,500,000 digit computations. The latest output on the 6,500,000 digit computation is As of Sun 11 Apr 2021 18:04:26 there were 5810176 iterations done in 1.2619*10^7 seconds. That is 0.46041 iterations/s. 67.37117% complete. It should take 216.766 days or 1.873*10^7s, and finish Mon 21 Jun 2021 11:03:14. The 5,500,000 is being done by a totally different method. Its latest output is 6686208 iterations in 1.46938392445428*^7 seconds. 90.27240044247787% done. When they are complete we will know for a fact what 5,500,000 digits of the MRB constant are! If the 6,500,000 digit computation gives the same answer as the 6,000,000 digit computation, experience has taught us, there is no reason to doubt it will be right.
Posted 2 years ago
 Probably the last update on the 5,500,000 digit computation: Print[7211520/7405568*100., "% done."] 97.37970132743364% done. When it is done, having the same first 5,500,000 digits found in the previous 6,000,000 digit computation by a totally different method, it will prove beyond any shadow of a doubt the 5,500,000 digits are correct.Stay tuned!
Posted 2 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 2 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 and 1.38935720536301*10^7 s. respectively

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

0.*10^-5024993


That means that the 5,000,000 digit computation was actually accurate to 5024993 decimals!!!

For the complete blow-by-blow see MRBSC2 6 million 1st fourth.nb.

Attachments:
Posted 2 years ago

## Update on the 6,000,000 digit computation.

I'm getting so close, I can taste the victory!!!!!

Latest output:

As of Mon 15 Mar 2021 18:20:22 there were 7221248 iterations done in 1.258410^7 seconds. That is 0.57383 iterations/s. 90.71263% complete. It should take 160.543 days or 1.38710^7s, and finish Tue 30 Mar 2021 15:45:20.

Posted 2 years ago
 It's been a while since I checked in with you all, so here is an encouraging update! The 5,500,000 digits computation using only Crandall's original method can be found here: https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nbThe latest output is In[85]:= DateString[]  5235200 iterations in 1.13741582450835*10^7 seconds. "Thu 4 Mar 2021 08:03:45" 70.6928% done.  The 6,500,000 digits using my proven method.:https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC26p5million.nbThe latest output is  As of Thu 4 Mar 2021 07:53:12 there were 4317184 iterations done in 9.2996*10^6 seconds. That is 0.46423 iterations/s. 50.05937% complete. It should take 214.983 days or 1.857*10^7s, and finish Sat 19 Jun 2021 16:14:58.  The 6,000,000 digits computation using my method found in the previous messages, here: https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nbThe latest output is As of Thu 4 Mar 2021 08:47:02 there were 6662144 iterations done in 1.1599*10^7 seconds. That is 0.57435 iterations/s. 83.68922% complete. It should take 160.398 days or 1.386*10^7s, and finish Tue 30 Mar 2021 12:16:52. P.S as of 04:00 am 1/2/2021, this discussion had 300,000 views!And as of 08:30 pm 2/3/2021, this discussion had 330,000 views!
Posted 2 years ago

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

Here is where I posted its progress compared to some previous computers. It broke all new records for large computations!

Here are the documenting notebooks for the MRB constant supercomputer timings and computation times:

1 million digits took 44 hours, as recorded in the attached "44 hour million.nb".

Since I've prepared a lot of redundancy into the MRB constant supercomputer 2, I rushed ahead and started the 8th attempt at 6,000,000 digits with half of its nodes. I'll post a few updates here, and if it looks like I will be successful, I will move all the updates to a new reply. Wish me luck!

The code that I'm using is the same one found in the reply that starts with "4th Try at 6,000,000 (6 million) Digits" Here is the latest update on the Wolfram could:

The computers went offline. With 16 kernels and 16 active cores, Ii would have taken 116 days.

Nonetheless, I did get some great new records for documented computation times while using V12.1:

Proof in the attached "MRBSC2speedrecordsforV12.1.nb".

Don'tlook now, but I'm trying 6,000,000 again. Here is a portion of the notebook:

Out[3]= {"KernelObject"[1, "DigitalStorm-PC"],
"KernelObject"[2, "DigitalStorm-PC"],
"KernelObject"[3, "DigitalStorm-PC"],
"KernelObject"[4, "DigitalStorm-PC"],
"KernelObject"[5, "DigitalStorm-PC"],
"KernelObject"[6, "DigitalStorm-PC"],
"KernelObject"[7, "DigitalStorm-PC"],
"KernelObject"[8, "DigitalStorm-PC"],
"KernelObject"[9, "DigitalStorm-PC"],
"KernelObject"[10, "DigitalStorm-PC"],
"KernelObject"[11, "DigitalStorm-PC"],
"KernelObject"[12, "DigitalStorm-PC"],
"KernelObject"[13, "WIN-1AA39U1LQNT"],
"KernelObject"[14, "WIN-1AA39U1LQNT"],
"KernelObject"[15, "WIN-1AA39U1LQNT"],
"KernelObject"[16, "WIN-1AA39U1LQNT"],
"KernelObject"[17, "WIN-1AA39U1LQNT"],
"KernelObject"[18, "WIN-1AA39U1LQNT"],
"KernelObject"[19, "WIN-1AA39U1LQNT"],
"KernelObject"[20, "WIN-1AA39U1LQNT"], "KernelObject"[21, "local"],
"KernelObject"[22, "local"], "KernelObject"[23, "local"],
"KernelObject"[24, "local"], "KernelObject"[25, "local"],
"KernelObject"[26, "local"], "KernelObject"[27, "local"],
"KernelObject"[28, "local"], "KernelObject"[29, "local"],
"KernelObject"[30, "local"], "KernelObject"[31, "local"],
"KernelObject"[32, "local"], "KernelObject"[33, "local"],
"KernelObject"[34, "local"], "KernelObject"[35, "local"],
"KernelObject"[36, "local"]}

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

SetPrecision[13.5,
pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/64]**)x = SetPrecision[x, pr/16];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/16]**)x = SetPrecision[x, pr/4];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
ll]/ll],pr/4]**)x = SetPrecision[x, pr];
xll = x^ll; z = (ll - xll)/xll;
t = 2 ll - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr] (ll - 1)/
t2 + (ll + 1) z/(2 ll t) -
SetPrecision[13.5,
pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/
ll],pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]];
ctab = ParallelTable[Table[c = b - c;
ll = start + l - 2;
b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
c, {l, chunksize}], Method -> "Automatic"];
s += ctab.(xvals - 1);
start += chunksize;
st = SessionTime[] - T0; kc = k*chunksize;
ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
If[kc > 1,
Print["As of  ", DateString[], " there were ", kc,
" iterations done in ", N[st, 5], " seconds. That is ",
N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7],
"% complete.", " It should take ", N[ti, 6], " days or ",
N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]];
Print[];, {k, 0, end - 1}];
N[-s/d, pr]];
t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ",
DateString[], ". Proccessor and actual time were ", t2[[1]], " and ",
SessionTime[] - T0, " s. respectively"];
Print["Enter MRB1 to print ",
Floor[Precision[
MRB1]], " digits. The error from a 5,000,000 or more digit \
calculation that used a different method is  "]; N[MRB - MRB1, 20]

During evaluation of In[4]:= Start time is Tue 20 Oct 2020 09:19:39.

During evaluation of In[4]:= Iterations required: 7959598

During evaluation of In[4]:= Will give 3887 time estimates, each more accurate than the previous.

During evaluation of In[4]:= Will stop at 7960576 iterations to ensure the precision of around 6029999 decimal places.


The computers went offline. With 36 kernels and 26 active cores, it would have taken 83 days.

Now, I'm using the same code and setup, with prec=1000000, to try to break my 44 hour 1 million digits record.

That attempt using the maximum number of kernels allowed over my finite number of cores was no faster than using equal cores and kernels. That is in accordance with Wolfram's suggestions.

I'm not sure what to do next -- will try to make some progress, somehow and report back then.

## Previously

Here is my mini-cluster of the fastest 3 computers (the MRB constant supercomputer 0) mentioned below: The one to the left is my custom-built extreme edition 6 core and later with an 8 core 3.4 GHz Xeon processor with 64 GB 1666 MHz RAM.. The one in the center is my fast little 4 core Asus with 2400 MHz RAM. Then the one on the right is my fastest -- a Digital Storm 6 core overclocked to 4.7 GHz on all cores and with 3000 MHz RAM.

## 3/23/2019

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

3.7 GH overclocked up to 4.7 GHz on all Intel 6 cores at 3000 MHz RAM and 4 cores of 3.6 GHz at 2400 MHz RAM,

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

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

Total: $2,695.00. That is less than 1/10th the price of any single computer that can do the same as the new cluster!!!!!! Well, I rebuilt the MRB constant supercomputer stronger than ever. I will call it the MRB constant supercomputer 2. Here is how it looks: ![enter image description here][1111] The MRB constant supercomputer 3 will have a combined 288 GB of 3200 to 4800 Mhz DCDR4 and DDR5 RAM! Attachments: Posted 2 years ago  I said, "would get back to you when I made some progress." Well here's what I did. 1 node of the MRB constant supercomputer is calculating 6 million digits using the same program used above. Another node is calculating 7,500,000 digits using an experimental, faster program, which digits I will round down to 7,000,000. The remaining node is calculating 5,500,000 digits using only Richard Crandall's original algorithm. If they all three agree to 5,500,000 digits, I will be certain that those digits are correct. And if the 6,000,000 are the same found in the rounded down 7,500,000, will be pretty-well satisfied that they are correct. And experience has taught me that the last one is probably correct to 7,000,000 or more.The 5,500,000 digits computation using only Crandall's original method can be found here: https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nb .The 6,000,000 digits computation using my method found in the previous message, here: https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nb The 7,500,000 digits computation using the experimental, faster method, here: https://www.wolframcloud.com/obj/bmmmburns/Published/first2%207%20million%2011p3.nb .The node tasked with the 7,500,000 digits computation using the experimental, faster method crashed, so I reassigned it 6,500,000 digits using my proven method. It is now found here: . Posted 2 years ago (You guessed it!) my 5,555,555 digit computation died from another long term power outage. I need a household generator! If I get a generator, I could calculate up to10,000,000 digits! P. S. Several times, I mentioned Crandall's first MRB constant Dirichlet's eta derivative formula: . I concluded with what I think is the fastest way of computing it in the message that starts out with " 4/22/2019". But there is something else I would like to test out: At https://www.sciencedirect.com/science/article/pii/S0022314X15001882 , there is the Adell-Lekuona scheme to quickly calculate the mth derivatives of eta of m. Stay tuned for what I find out!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Edit: I got some meager results of calculating the nth derivatives of eta of n from the Adell-Lekuona scheme: ## ... First I define c and the nth derivative of eta sub 1 of n from the scheme: c[t_, n_] := (-1.30.)^(n + t)* Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1.30.)^(n - l - j)*(Log[l + j + 1]/(l + j + 1))^t, {j, 0, n - l}], {l, 0,n}]; etad[t_] := (2/3)* NSum[c[t, n]/3^n, {n, 0, 20}, Method -> "AlternatingSigns", WorkingPrecision -> 30]  Then I compare the results with the actual derivatives: In[152]:= etad[2] - N[Derivative[n][DirichletEta][n] /. n -> 2, 30] Out[152]= -5.6495702147568955843*10^-12 In[153]:= etad[3] - N[Derivative[n][DirichletEta][n] /. n -> 3, 30] Out[153]= 3.4964879453028546174*10^-12 In[154]:= etad[4] - N[Derivative[n][DirichletEta][n] /. n -> 4, 30] Out[154]= -1.19233015142032460531*10^-12 In[168]:= etad[10] - N[Derivative[n][DirichletEta][n] /. n -> 10, 30] Out[168]= 3.859680615418530806797*10^-14 In[190]:= etad[100] - N[Derivative[n][DirichletEta][n] /. n -> 100, 30] Out[190]= -1.8845740316090756479036*10^-51  I'm getting more digits as the value of n goes up.. ## EDIT (3 days later) Here are more than 224 accurate digits of the MRB constant via only the Adell-Lekuona scheme in 44 min: First, I calculated 240 digits that have been proven to be correct to well beyond 224 digits:  In[132]:= m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 240, Method -> "AlternatingSigns"] Out[132]= \ 0.18785964246206712024851793405427323005590309490013878617200468408947\ 7231564660213703296654433107496903842345856258019061231370094759226630\ 4389293488961841208373366260816136027381263793734352832125527639621714\ 893217020762820621715167151756  Then I entered a line that computes the nth derivatives of eta of n:  c[t_, n_] := (-1240)^(n + t)*Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)* (N[Log[l + j + 1], 250]/(l + j + 1))^t, {j, 0, n - l}], {l, 0, n}]; etad[t_] := (2/3)*N[ Sum[c[t, n]/3^n, {n, 1, 500} ], 250]  Then I entered the program to compute the MRB constant from the derivatives:  Timing[shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 120}, Method -> "WynnEpsilon",WorkingPrecision -> 240, NSumTerms -> 90]]  Here are the time it took and the digits calculated:  {2656.11, \ 0.18785964246206712024851793405427323005590309490013878617200468408947\ 7231564660213703296654433107496903842345856258019061231370094759226630\ 4389293488961841208373366260816136027381263793734352832125527639621714\ 893217020762821}  Here those digits are proven to be correct to 224 digits:  In[138]:= m - shot Out[138]= 0.*10^-224  Compare with my fastest 224 digit computation, 62.5 milliseconds: In[72]:= Print["Start time is ", ds = DateString[], "."]; prec = 225; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*= 4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4, pc = Min[3 pc, pr/4]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[ Log[ll]/ ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(** N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 32]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Enter MRBtest2 to print ", Floor[Precision[MRBtest2]], " digits"]; m3M - MRB1 During evaluation of In[72]:= Start time is Mon 7 Sep 2020 03:19:21. During evaluation of In[72]:= Iterations required: 298 During evaluation of In[72]:= Will give 1 time estimates, each more accurate than the previous. During evaluation of In[72]:= Will stop at 2048 iterations to ensure precision of around 226 decimal places. During evaluation of In[72]:= Finished on Mon 7 Sep 2020 03:19:21. Processor time was 0.0625 s. During evaluation of In[72]:= Enter MRBtest2 to print \[Infinity] digits Out[78]= 0.*10^-224  That is 40,615 times faster. My use of the Adell-Lekuona scheme has a way to go. P.S. I did a lot of research and found out that my use of the Adell-Lekuona scheme is no faster, for up to around half a hundred digits than the following "brute force" one. And I show where it is a great deal slower! The scheme's main advantage seems to be being able to compute more of a maximum of digits (like the above 224, which to me seems impossible to match with a PC and general math software). In[45]:= m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100, Method -> "AlternatingSigns"]; Timing[ c1 = Limit[(-1)^n/n! Derivative[n][DirichletEta][x] /. n -> 1, x -> 1]; m + (c1 + NSum[(-1)^n/n! Derivative[n][DirichletEta][n], {n, 2, 30}, Method -> "WynnEpsilon", WorkingPrecision -> 100])] Out[45]= {7.84375, -2.40588*10^-48}  vs scheme: m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100, Method -> "AlternatingSigns"] Out[1]= 0.\ 1878596424620671202485179340542732300559030949001387861720046840894772\ 3156466021370329665443217278 In[41]:= c[t_, n_] := (-160)^(n + t)* Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)* (Log[l + j + 1]/(l + j + 1))^t, {j, 0, n - l}], {l, 0, n}]; etad[t_] := (2/3)* N[ Sum[c[t, n]/3^n, {n, 1, 90} ], 60] In[42]:= Timing[ shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 30}, Method -> "WynnEpsilon", WorkingPrecision -> 60, NSumTerms -> 60]] Out[42]= {12.5781, \ 0.187859642462067120248517934054273230055903094615556440737580} In[43]:= m - shot Out[43]= 2.84582345434425*10^-46  Posted 2 years ago  While the 5,555,555 digit calculation is working, I thought I would mention my latest mini-project. I wanted to look at computing the MRB constant, (0.18785964...) through a generalized continued fraction for z^(1/z).At Mathworld we see a suitable continued fraction here. 1 + (2 (x - 1))/(x^2 + 1 + ContinuedFractionK[-(n^2 x^2 - 1) (x - 1)^2, (2 n + 1) x (x + 1), {n, \[Infinity]}]) .It looks like. -With only 10 terms, I was able to calculate 4 decimals of the constant, 0.1878, the equivalent of adding up to 299,999 terms by brute force! N[1/2 - Sum[(-1)^x* {(2*(x - 1))/(ContinuedFractionK[ (x - 1)^2*(-(n^2*x^2 - 1)), (2*n + 1)*x*(x + 1), {n, 3}] + x^2 + 1) + 1}, {x, 1, 10^1}]] . -That gives 0.1878368104323782.See, N[Sum[(-1)^n (n^(1/n) - 1), {n, 1, 299999}]] gives 0.18783862276177388.It looks like the following.. - Posted 2 years ago  Well, I've tried 6,000,000 at least 5 times and am getting nowhere! I started a 5,555,555 digit computation on 19 Jun 2020 22 : 20 : 08, to break my bad luck spree: Here are my latest results:I'll only post 1 update a week, so as not to abuse the message board. Posted 3 years ago In the same vein of a non-trivial approximation: The MRB constant =m. m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 30, Method -> "AlternatingSigns"];  We know from previous posts, To find how fast this integral converges to m, I entered lsmall = Table[ m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x}, WorkingPrecision -> 40], {x, 1, 20}]; N[Ratios[1/lsmall], 15]  followed by the slower lbig = Table[ m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x}, WorkingPrecision -> 240], {x, 101, 120}]; N[Ratios[1/lbig], 15]  and ended up with values that converged to 23.2958716448535.  Using those ratios, it looks like Since that is a form of 0/0, we can use L'Hospital's Rule and see that it is true: Limit[(Csch[\[Pi] t] Im[(1 + I t)^(1/( 1 + I t))])/(Csch[\[Pi] (t + 1)] Im[(1 + I (t + 1))^(1/( 1 + I ( t + 1)))]), t -> Infinity]  gives Now for the part that is similar to the approximations mentioned in the immediate, previous post. You may know that N[20/(E^Pi - Pi), 9]  gives 1.00004500.  While N[2 - 100/(E^Pi/m - E^Pi), 8]  gives 1.0004005.  Furthermore, N[2 - 100/(E^Pi/m - E^Pi), 12]/N[20/(E^Pi - Pi), 12]  gives 1.00035544632.  While N[3 - 100/(E^Pi/m - E^Pi), 12] - N[20/(E^Pi - Pi), 12]  gives 1.00035546231.  Holy double, double vision Batman! There is a way to make the approximations of 20/(E^Pi - Pi) vs 2 - 100/(E^Pi/x - E^Pi), where x is a relation to m, equal to 11 digits, instead of just similar to 9, using the parking constant. E^Pi is involved in a term again! (The term is a Cosmological constant, of sorts.) (*parking constant,c*) c = NIntegrate[ E^(-2*(EulerGamma + Gamma[0, t] + Log[t])), {t, 0, Infinity}, WorkingPrecision -> 50, MaxRecursion -> 20];  Let ma be the MRB constant with that term: ma = m + (2/3 - E^Pi)/(1/3 - c)/10^6;  Calculating more digits of 20/(E^Pi - Pi): N[20/(E^Pi - Pi), 12]  gives 1.00004500307.  Calculating the new sum with ma instead of m: N[2 - 100/(E^Pi/ma - E^Pi), 12]  gives 1.00004500308.  What about the second of the similar-looking approximated sums, N[2 - 100/(E^Pi/x - E^Pi), 15]/N[20/(E^Pi - Pi), 15] vs.N[3 - 100/(E^Pi/x - E^Pi), 16] - N[20/(E^Pi - Pi), 16]? So we have the new x, ma. Then N[2 - 100/(E^Pi/ma - E^Pi), 15]/N[20/(E^Pi - Pi), 15]  gives 1.00000000001744.  While N[3 - 100/(E^Pi/ma - E^Pi), 16] - N[20/(E^Pi - Pi), 16]  gives the exactly the same value of 1.000000000017440.  ## Holy corrected vision Batman! Posted 3 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. In[1]:= m = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity},Method -> "AlternatingSigns", WorkingPrecision ->207];In[2]:= d=114705489440921816400568391832103;N[10539265076340778455746831348074621/(10d)+(1315939211433987901830906252006812 Sqrt[2]) / d+(2238154781652703157536445225769983 Sqrt[5]) / (2d)+(464968409472439567819541453580715 6^(1/6)) / d-(1917024616230569159116802658552184 Pi ) / d-m]Out[2]= -9.93177*^-201 Posted 3 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 3 years ago  In 38 1/2 days, I computed 100,000 digits of the MRB constant from the Here is the code: Timing[mi = NIntegrate[ Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 100000, Method -> "Trapezoidal", PrecisionGoal -> 100000, MaxRecursion -> 30]] I attached the notebook with the results. Attachments: Posted 3 years ago ## Breaking News At https://math.stackexchange.com/questions/2564705/what-are-some-working-models-that-are-a-fit-the-formula-for-the-mrb-constant/3505694#3505694, an internet scholar going by the user name Dark Malthorp found the following formulas for CMRB. Some may be useful for breaking new records. I'm particularly am fond of CMRB=. It seems to be true, as shown next.  Quiet[ Timing[mi = NIntegrate[ Im[(1 + I t)^(1/(1 + I t))]/Sinh[Pi t], {t, 0, Infinity}, WorkingPrecision -> 1000, Method -> "Trapezoidal"]][[1]]]  gives 5.29688 seconds.  Timing[ ms = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]][[1]]  gives 0.234375 seconds.  mi - ms  gives -3.*10^-998. Posted 3 years ago Well, my internet went out!!!!! To get it working, I had to reset my router. This killed the computation at 44% at 8:17:42 am EST | Thursday, November 28, 2019. I attached the notebook showing all of my progress. ## 4th Try at 6,000,000 (6 million) Digits I thought about waiting to see if I was successful to 30% completion before posting about my new effort, but being isolated, I kinda need someone to talk to, so here's the code and results so far: Start time is Wed 18 Mar 2020 21:14:14.  ... 796672 iter. done in 8.647*10^5 s. Ave. 0.92134iter./s. Should take 99.990 days or 8.639*10^6s. Finish Fri 26 Jun 2020 20:59:28. {10,% done.} ...  ## 5th Try at 6,000,000 (6 million) Digits The internet connection between my computers went out again! I guess I'll have to use just one computer and calculate my 6,000,000 digits the slow way. Well, at least this MRB records posting reached a milestone of over 120,000 views on 3.31.2020, around 4:00 am. So I restarted the computation on a single computer. I'm using basically the same code as before.  Here are the most recent results at 9:12:15 pm EDT | Friday, May 1, 2020: 1409024 iter.done in 2.71910^6 s.Ave.0.51820 iter./s.It should take 177.78 days or 1.53610^7 s. Finish Fri 25 Sep 2020. 04 : 37 : 56. N[1409024/ 7960576 *100] "percent done"  17.7 "percent done" ## The Seventh attempt at Calculating 6,000,000 digits Speaking of methods of computation, at Fri 11 Sep 2020 21:41:41, I started my seventh attempt at calculating 6,000,000 digits of the MRB constant with one node of the MRB constant supercomputer. Here are the MRB method program and recent output. Print["Start time is ", ds = DateString[], "."]; prec = 6000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*= 4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precision of around ", pr, " decimal places."]; Print[]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4, pc = Min[3 pc, pr/4]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[ Log[ll]/ ll],pr/4]**)x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(** N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 32]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print["As of ", DateString[], " there were ", kc , " iterations done in ", N[st, 5], " seconds. That is ", N[kc/st, 5], " iterations/s. ", N[kc/(end* chunksize)*100, 7], "% complete.", " It should take ", N[ti, 6], " days or ", N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]]; Print[];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor and actual time were ", t2[[1]], " and ", SessionTime[] - T0, " s. respectively"]; Print["Enter MRB1 to print ", Floor[Precision[MRB1]], " digits. The error from a 5,000,000 or more digit calculation \ that used a different method is "]; N[MRB - MRB1, 20]   As of Sat 19 Sep 2020 09:00:54 there were 356352 iterations done in 6.4555*10^5 seconds. That is 0.55201 iterations/s. 4.476460% complete. It should take 166.890 days or 1.442*10^7s, and finish Thu 25 Feb 2021, 19:03:08.  See https://www.wolframcloud.com/obj/bmmmburns/Published/MRB%202020.nb for up-to-date notebook. Due to a battery backup that surged, the MRB constant supercomputer suffered great damage, and of course, the computation failed. For the conclusion of the 6-million digit saga, CTRL+F "I DECLARE VICTORY!" Attachments: Posted 3 years ago ## 8/24/2019 It's time for more digits! Using the 3-node MRB constant supercomputer, I started the 6 million-digit computation of the MRB constant. ## UPDATE For some unknown reason, the kernel closed at 9:09:35 pm EDT | Saturday, August 31, 2019. I can't stand not trying to make progress!!!! so I started the 6 million digits run again. More info coming soon! Start time is Mon 16 Sep 2019 15:35:29.  There seems to be a major problem with calculating 6,000,000 digits via my program. The problem is reproducible -- the kernel went offline at the same time in both tries. I'm not sure about my next step!!!!!!! ## UPDATE I'm experimenting with virtual RAM. I created a 64 to 128 GB virtual RAM page and started the computation again on Mon 7 Oct 2019 20:50:12. Here are some random moments where I recorded the memory usage: 5:36:52 pm EDT | Saturday, October 26, 2019: {15,% done.} 1273856 iter. done in 1.630*10^6 s. Ave. 0.78157iter./s. Should take 117.87 days or 1.018*10^7s. Finish Sun 2 Feb 2020 17:45:26. {16,% done.}  ... 7:10:12 pm CST | Tuesday, November 26, 2019: {42,% done.} 3424256 iter. done in 4.314*10^6 s. Ave. 0.79375iter./s. Should take 116.06 days or 1.003*10^7s. Finish Fri 31 Jan 2020 22:20:28. {43,% done.}  More to come. Attachments: Posted 4 years ago ## 3/23/2019 Well, my mania struck again!!!!! I bought another computer that I can't afford. Added to my cluster of 3.7 GH overclocked up to 4.7 GHz on all Intel 6 cores at 3000 MHz RAM and 4 cores of 3.6 GHz at 2400 MHz RAM, with optimized use of kernel priority in my programs, I should be able to compute up to 10 million digits! And, according to results from a well known cloud I tried out, my cluster should be faster than a Intel Xeon Platinum 8151 @ 3.4 GHz with 24 cores!! (in using my programs for many computations of MRB) Here are the details of my new computer: Processor: Intel Core i9-9900K (5.0 GHz Turbo) (16-Thread) (8-Core) 3.6 GHz. CPU Boost: Stage 2: Overclock CPU - Up to 5.1GHz on All CPU Cores at 3200 Mhz RAM Extreme Cooling: H20: Stage 2: Corsair H115i PRO - 280mm Liquid CPU Cooler (Fully Sealed + No Maintenance) Total:$2,695.00.

That is less than 1/10th the price of any single computer that can do the same as the new cluster!!!!!!

Using the 3 node MRB constant supercomputer, I got the following red column for seconds on computing the MRB constant. Documented in the attached ":3 fastest computers together 3.nb." Pay special attention to the new record 45.5 hour million digit computation!!!!!!!

Attachments:
Posted 4 years ago

# Attempts at a 5,000,000 digit calculation

## First effort: Tue 22 May 2018

I started a 5,000,000 digits calculation on my 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB DDR4 ram running at 2400 MHz in Windows 10 Pro using a version of my Burns-Crandall hybrid code supercharged with 4 iterations of my 4th order convergence subroutine.

See April 2018 5 million digits try.nb for exact code and results of the incomplete computation.

Here are some of the results:

Start time is Tue 22 May 2018 01:02:37.
Iterations required: 6632998
Will give 3239 time estimates, each more accurate than the previous.
Will stop at 6633472 iterations to ensure precision of around 5024999 decimal places.
0 iterations done in 3301. seconds. Should take 2.534*10^9 days or 2.189*10^14s, finish Mon 11 Nov 6939709 17:32:23.
2048 iterations done in 6503. seconds. Should take 243.8 days or 2.106*10^7s, finish Sun 20 Jan 2019 19:11:08.
4096 iterations done in 9721. seconds. Should take 182.2 days or 1.574*10^7s, finish Tue 20 Nov 2018 05:57:47.
6144 iterations done in 1.295*10^4 seconds. Should take 161.8 days or 1.398*10^7s, finish Tue 30 Oct 2018 21:15:01.
8192 iterations done in 1.623*10^4 seconds. Should take 152.1 days or 1.314*10^7s, finish Sun 21 Oct 2018 03:44:45.
10240 iterations done in 1.964*10^4 seconds. Should take 147.3 days or 1.272*10^7s, finish Tue 16 Oct 2018 07:34:30.
12288 iterations done in 2.312*10^4 seconds. Should take 144.4 days or 1.248*10^7s, finish Sat 13 Oct 2018 11:43:37.
14336 iterations done in 2.667*10^4 seconds. Should take 142.8 days or 1.234*10^7s, finish Thu 11 Oct 2018 20:49:04.
16384 iterations done in 2.998*10^4 seconds. Should take 140.5 days or 1.214*10^7s, finish Tue 9 Oct 2018 12:13:43.
18432 iterations done in 3.326*10^4 seconds. Should take 138.5 days or 1.197*10^7s, finish Sun 7 Oct 2018 13:48:39.


I felt this was going too slow so I got more computing power!!!

## Second effort: Sun 20 Jan 2019 21:06:58

I've made a lot better progress with the following!!!

6 kernels, 3.7 GH overclocked up to 4.7 GH, Intel 6core 3000MH RAM, w/ 8 kernels of 3.6 GH 4 core, 2400MH RAM (with optimized use of kernel priority)

Needs["SubKernelsLocalKernels"]
Block[{$mathkernel =$mathkernel <> " -threadpriority=2"},
LaunchKernels[]](*optimized use of kernel priority for master computer being the fastest one*)


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

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

  Start time is Sun 20 Jan 2019 21:06:58.

Iterations required: 6632998

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

Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places.

0 iterations done in 1893. seconds. Should take 1.454*10^9 days or 1.256*10^14s. Finish Sun 16 Apr 3981600 03:48:25.

{0,% done.}

2048 iterations done in 3801. seconds. Should take 142.5 days or 1.231*10^7s. Finish Wed 12 Jun 2019 08:24:54.

{0,% done.}

4096 iterations done in 5774. seconds. Should take 108.2 days or 9.351*10^6s. Finish Thu 9 May 2019 02:36:43.

{0,% done.}

6144 iterations done in 7744. seconds. Should take 96.76 days or 8.360*10^6s. Finish Sat 27 Apr 2019 15:27:12.

{0,% done.}

8192 iterations done in 9655. seconds. Should take 90.48 days or 7.818*10^6s. Finish Sun 21 Apr 2019 08:42:56.

{0,% done.}

10240 iterations done in 1.160*10^4 seconds. Should take 86.95 days or 7.512*10^6s. Finish Wed 17 Apr 2019 19:49:38.

{0,% done.}

12288 iterations done in 1.351*10^4 seconds. Should take 84.43 days or 7.295*10^6s. Finish Mon 15 Apr 2019 07:29:22.

{0,% done.}

14336 iterations done in 1.544*10^4 seconds. Should take 82.67 days or 7.143*10^6s. Finish Sat 13 Apr 2019 13:14:41.

{0,% done.}

16384 iterations done in 1.737*10^4 seconds. Should take 81.39 days or 7.032*10^6s. Finish Fri 12 Apr 2019 06:34:15.

{0,% done.}

18432 iterations done in 1.931*10^4 seconds. Should take 80.42 days or 6.948*10^6s. Finish Thu 11 Apr 2019 07:06:55.

{0,% done.}


![enter image description here][1]

See 5 million 01 2019.nb for full progress. The cluster is processing 1.024 5,000,000 digit iterations of n^(1/n) per second. It is completing 1% every 18 hours, 3 minutes and 36 seconds.

Well, the power went out here in INDY, again.

My 6 year old battery backup is becoming worthless on handling 2 computers for very long. I will try to build some better household infrastructure. Plus, there is still the possibility of breaking my program up so it does smaller portions of the computation at a time. But, I haven't figured how to do that yet!

I will let you know when I'm ready to try again. It took over 8 tries for 4 million digits, so I'm not heartbroken that this second try of 5 million digit didn't work out.

## Third effort: 5/3/2019

Using the MRB constant supercomputer described in the next post, we now have much better progress, as shown in 5 million 05 2019.nb:

   Start time is Sun 12 May 2019 10:23:26.

Iterations required: 6632998

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

Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places.

0 iterations done in 1482. seconds. Should take 1.138*10^9 days or 9.829*10^13s. Finish Thu 23 Jan 3116775 18:57:34.

{0,% done.}

2048 iterations done in 2986. seconds. Should take 111.9 days or 9.672*10^6s. Finish Sun 1 Sep 2019 08:57:12.

{0,% done.}

4096 iterations done in 4503. seconds. Should take 84.39 days or 7.292*10^6s. Finish Sun 4 Aug 2019 19:49:39.

{0,% done.}

6144 iterations done in 6036. seconds. Should take 75.42 days or 6.516*10^6s. Finish Fri 26 Jul 2019 20:21:33.

{0,% done.}

8192 iterations done in 7562. seconds. Should take 70.87 days or 6.123*10^6s. Finish Mon 22 Jul 2019 07:13:15.

{0,% done.}

10240 iterations done in 9106. seconds. Should take 68.27 days or 5.898*10^6s. Finish Fri 19 Jul 2019 16:47:37.

{0,% done.}

12288 iterations done in 1.064*10^4 seconds. Should take 66.46 days or 5.743*10^6s. Finish Wed 17 Jul 2019 21:32:38.

{0,% done.}

14336 iterations done in 1.218*10^4 seconds. Should take 65.24 days or 5.636*10^6s. Finish Tue 16 Jul 2019 16:03:55.

{0,% done.}

16384 iterations done in 1.372*10^4 seconds. Should take 64.31 days or 5.556*10^6s. Finish Mon 15 Jul 2019 17:46:42.

{0,% done.}

18432 iterations done in 1.527*10^4 seconds. Should take 63.62 days or 5.496*10^6s. Finish Mon 15 Jul 2019 01:09:08.

{0,% done.}


Wish me luck!

Here is the latest output:

131072 iterations done in 1.026*10^5 seconds. Should take 60.11 days or 5.193*10^6s. Finish Thu 11 Jul 2019 13:00:35.

{1,% done.}

133120 iterations done in 1.042*10^5 seconds. Should take 60.10 days or 5.193*10^6s. Finish Thu 11 Jul 2019 12:53:13.

{2,% done.}

135168 iterations done in 1.058*10^5 seconds. Should take 60.09 days or 5.192*10^6s. Finish Thu 11 Jul 2019 12:35:29.

{2,% done.}

137216 iterations done in 1.074*10^5 seconds. Should take 60.09 days or 5.192*10^6s. Finish Thu 11 Jul 2019 12:29:39.

{2,% done.}

139264 iterations done in 1.090*10^5 seconds. Should take 60.08 days or 5.191*10^6s. Finish Thu 11 Jul 2019 12:15:25.

{2,% done.}.


Followed by

196608 iterations done in 1.543*10^5 seconds. Should take 60.27 days or 5.207*10^6s. Finish Thu 11 Jul 2019 16:48:37.

{2,% done.}

198656 iterations done in 1.559*10^5 seconds. Should take 60.26 days or 5.207*10^6s. Finish Thu 11 Jul 2019 16:40:38.

{2,% done.}

200704 iterations done in 1.575*10^5 seconds. Should take 60.25 days or 5.206*10^6s. Finish Thu 11 Jul 2019 16:26:21.

{3,% done.}


Followed by

264192 iterations done in 2.075*10^5 seconds. Should take 60.30 days or 5.210*10^6s. Finish Thu 11 Jul 2019 17:34:10.

{3,% done.}

266240 iterations done in 2.091*10^5 seconds. Should take 60.29 days or 5.209*10^6s. Finish Thu 11 Jul 2019 17:24:24.

{4,% done.}


Well, for an unknown reason Mathematica 11.3 asked whether I wanted to close the program and had not displayed any new information since my last checking it 18 hours ago.

## Fourth effort: Thu 16 May 2019 15:39:40

I restarted the 5 million digit computation. For an unknown reason it is a little slower this time, but what's important is that it gets completed! See attached B 5 million 05 2019.nb.

0 iterations done in 1520. seconds. Should take 1.167*10^9 days or 1.008*10^14s. Finish Sun 13 Dec 3197801 13:09:30.

{0,% done.}

2048 iterations done in 3103. seconds. Should take 116.3 days or 1.005*10^7s. Finish Mon 9 Sep 2019 23:32:26.

{0,% done.}

4096 iterations done in 4697. seconds. Should take 88.04 days or 7.607*10^6s. Finish Mon 12 Aug 2019 16:42:17.

{0,% done.}

6144 iterations done in 6298. seconds. Should take 78.69 days or 6.799*10^6s. Finish Sat 3 Aug 2019 08:14:25.

{0,% done.}

8192 iterations done in 7899. seconds. Should take 74.02 days or 6.396*10^6s. Finish Mon 29 Jul 2019 16:13:37.

{0,% done.}

10240 iterations done in 9465. seconds. Should take 70.96 days or 6.131*10^6s. Finish Fri 26 Jul 2019 14:47:42.

{0,% done.}

12288 iterations done in 1.102*10^4 seconds. Should take 68.87 days or 5.950*10^6s. Finish Wed 24 Jul 2019 12:33:43.

{0,% done.}

14336 iterations done in 1.260*10^4 seconds. Should take 67.48 days or 5.830*10^6s. Finish Tue 23 Jul 2019 03:13:52.

{0,% done.}

16384 iterations done in 1.418*10^4 seconds. Should take 66.44 days or 5.740*10^6s. Finish Mon 22 Jul 2019 02:08:54.

{0,% done.}


6:56:20 pm EDT | Sunday, May 19, 2019:

{4,% done.}

331776 iterations done in 2.710*10^5 seconds. Should take 62.71 days or 5.418*10^6s. Finish Thu 18 Jul 2019 08:46:13.
{5,% done.}


# ...

It is completing 1% every 15 hours 16 minutes 40.08 seconds.

Should reach 99% at 4:56:20 am EDT | Friday, July 19, 2019.

4:39:40 am EDT | Friday, July 19, 2019

{98,% done.}

6567936 iterations done in 5.490*10^6 seconds. Should take 64.17 days or 5.544*10^6s. Finish Fri 19 Jul 2019 19:43:06.

{99,% done.}


It is completing 1% every 15 hours 0 minutes 0 seconds. Should reach 100% at 7:39:40 pm EDT | Friday, July 19, 2019.

{99,% done.}

Finished on Fri 19 Jul 2019 18:49:02. Processor time was 3.46012*10^6 s.

Actual time was 5.5409619988176*10^6

Enter MRBtest2 to print 5024991 digits

If you saved m3M, the difference between this and 4,000,000 known digits is 0.*10^-4000001


For this 5 million calculation of MRB using the 3 node MRB supercomputer

processor time was 40 days

and actual time was 64 days. That is faster than the 4 million digit computation using just one node.

See "Final results fo...nb" for full input, results and 5 million and a little more digits.

Attachments:
Posted 4 years ago
 Finished on Wed 16 Jan 2019 19:55:20, I computed over 4 million digits of the MRB constant!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!..... It took 65.13 days with a processor time of 25.17 days.On a 3.7 GH overclocked up to 4.7 GH on all cores Intel 6 core computer with 3000 MHz RAM. See attached notebook.Watch my reaction here. Attachments:
Posted 4 years ago

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

.

.

## First effort, Sep 04, 2015

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

Here is the code I am using:

(*Fastest (at MRB's end) as of 24 dEC 2014.*)
Block[{$MaxExtraPrecision = 50}, prec = 4000000;(*Number of required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 16, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = Cos[n ArcCos[3]]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; h = Log[ll]/ll; x = N[Exp[h], iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 4]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 2]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Difference from 3014991 known digits is ", MRBtest2 - m3M]; MRBtest2]  3014991 digits are saved as m3M. I will post several updates as edits here as I go. EDIT: As of Sat, Sept 5, 2015, the program is indicating that the run will take 3.3 months. EDIT: Having to run the program for over 3 months, there is a chance that I would suffer a power outage longer than the 15 minutes or so that my battery backup will run my computer! Of course I'll keep you posted if that happens. (I've tried calculations that took longer than that before!) ...Updates were installed closing Mathematica.. ## Second effort, Sept 10, 2015 EDIT I didn't know that upgrading to Windows 10 caused my Windows update option to read, automatically install updates, so my computer restarted. I started the 4,000,000 digit run again at 8:34 PM, Thursday Sept 10, 2015. This time I made sure the deffer updates option was chosen!! EDIT As of Sept 19,2015, the program says it will take 94 more days to complete the 4 million digit run. EDIT As of Sept 23,2015, 9:20 PM, the program says it will take 90.9563 more days to complete the 4 million digit run. EDIT As of Sept 27,2015, 9:20 PM, the program says it will take 86.9283 more days to complete the 4 million digit run ...Updates were installed closing Mathematica.. ## Third effort, Sept 28,2015 Well I started the 4 million digit search again. This time I installed the Windows 10 Fall Creators Update to try to avoid the automatic restarts! Per my habit above I will post updates in this message. The code I'm using is the same mentioned twice above that starts with The Windows 10 Fall Creators Update restarted my machine on Thursday, Nov 16, 2017 at 5:33 pm! ## Fourth effort, Dec 19, 2017 I applied some new update policies via LogMeIn, for windows to download but not apply updates. That should work! The new run looks like  1 : 15 : 58 pm EST | Sunday, December 17, 2017 ... done iter 96256 165140.1164436.  Then  (165140.1164436) sec/(96256 iterations) (5306880 iterations)/(3600sec/hour)/(24 hour/day)  gives 105.378 day. Entering "December 17, 2017+106 days" into Wolfram Alpha tells us the computation should be done around Monday, April 2, 2018. My computer went to sleep sometime between 10:15:51 pm EST | Thursday, December 28, 2017 and 9:22:00 am EST | Sunday, December 31, 2017 . ## Fifth effort, Jan 09, 2018 The output starts out with "Sun 7 Jan 2018 15:14:50" Iterations required: 5306398 end 3455 5306880 done iter 0 2374.6810043.  The latest result is done iter 92160 153642.6180409. Entering  (153642.6180409) sec/(92160 iterations) (5306880iterations)/(3600 sec/hour)/(24 hour/day)  gives 102.399 day or 3.4 months for the computation to run. Here is the latest output: done iter 3048960 5.1636602440434*10^6. N[3048960/5306880*100] says the computation is 57.453% done. ... My computer failed on 3/11/2018 at 8:30 am. I will break the program up, where it does a little at a time and saves a file with what progress has been made! ## Sixth effort, Sat 14 Apr 2018 I optimized my program to calculating 4019999 digits with my new system in Mathematica v. 11.3 (not kernel version). Posted below. On my new Xeon system, this optimized version gives V11.3 (not kernel version) a slight advantage over 11.2 (not kernel version)! Print["Start time is ", ds = DateString[], "."]; prec = 4000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*=4*number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/ ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); If[kc > 1, Print[kc, " iterations done in ", N[st, 3], " seconds.", " Should take ", N[ti, 2], " days or ", N[ti*24*3600, 2], "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \ output*); Print["Enter MRBtest2 to print ", Floor[Precision[ MRBtest2]], " digits"]; Print["If you saved m3M, the difference \ between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]  I'm going to play around with it an see what my patience and my computer's endurance amounts to. Here is the result: Start time is Sat 14 Apr 2018 14:00:33. Iterations required: 5306398 Will give 1296 time estimates, each more accurate than the previous. Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places. 4096 iterations done in 1.1810^4 seconds. Should take 1.810^2 days or 1.5*10^7s, finish Tue 9 Oct 2018 01:49:36. ... 2789376 iterations done in 4.21*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 07:21:24. That is 43.92 days from now (9:15:15 am EDT | Saturday, June 2, 2018). ... My computer crashed! ## Seventh! effort 27 Aug 2018 I started another 4 million digit run with my 3.7 GH overclocked up to 4.7 GH, Intel 6core and 6 kernels at 3000MH RAM, w/ 4 cores and 8 kernels of 3.6 GH at 2400MH RAM with optimized use of kernel priority. It is ultra fast!!!!!! Instead of around 100 days it says it will be done in less than 50 days. Here are the results thus far: Print["Start time is ", ds = DateString[], "."]; prec = 4000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4* number of physical cores*), tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["Will give ", end, " time estimates, each more accurate than the previous."]; Print["Will stop at ", end*chunksize, " iterations to ensure precsion of around ", pr, " decimal places."]; d = ChebyshevT[n, 3]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/24768]; Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr/4096, pc = Min[3 pc, pr/4096]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));]; (**N[Exp[Log[ll]/ll],pr/4096]**) x = SetPrecision[x, pr/1024]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/1024]*) x = SetPrecision[x, pr/256]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ ll]/ll],pr/256]*) x = SetPrecision[x, pr/64]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/64]**) x = SetPrecision[x, pr/16]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/16]**) x = SetPrecision[x, pr/4]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[ ll]/ll],pr/4]**) x = SetPrecision[x, pr]; xll = x^ll; z = (ll - xll)/xll; t = 2 ll - 1; t2 = t^2; x = x*(1 + SetPrecision[4.5, pr] (ll - 1)/ t2 + (ll + 1) z/(2 ll t) - SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/ ll],pr]*) x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]]; ctab = ParallelTable[Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}], Method -> "Automatic"]; s += ctab.(xvals - 1); start += chunksize; st = SessionTime[] - T0; kc = k*chunksize; ti = (st)/(kc + 10^-4)*(n)/(3600)/(24); Print[kc, " iterations done in ", N[st, 4], " seconds.", " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], "s, finish ", DatePlus[ds, ti], "."], {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", DateString[], ". Proccessor time was ", t2[[1]], " s."]; Print["Actual time was ", st]; (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \ output*); Print["Enter MRBtest2 to print ", Floor[Precision[ MRBtest2]], " digits"]; Print["If you saved m3M, the difference \ between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]  Start time is Mon 27 Aug 2018 17:22:11. Iterations required: 5306398 Will give 2592 time estimates, each more accurate than the previous. Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places. 0 iterations done in 1408. seconds. Should take 8.646*10^8 days or 7.470*10^13s, finish Sun 25 Jul 2369306 03:19:20. 2048 iterations done in 2831. seconds. Should take 84.90 days or 7.335*10^6s, finish Tue 20 Nov 2018 14:58:22. 4096 iterations done in 4261. seconds. Should take 63.90 days or 5.521*10^6s, finish Tue 30 Oct 2018 14:52:54. 6144 iterations done in 5752. seconds. Should take 57.49 days or 4.967*10^6s, finish Wed 24 Oct 2018 05:12:32. 8192 iterations done in 7237. seconds. Should take 54.26 days or 4.688*10^6s, finish Sat 20 Oct 2018 23:35:31. ... 210944 iterations done in 1.513*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:53:41. 212992 iterations done in 1.528*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:49:24. 215040 iterations done in 1.543*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:48:16. 217088 iterations done in 1.558*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:04:29. 219136 iterations done in 1.573*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:07:25. ... 548864 iterations done in 3.954*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:06:24. 550912 iterations done in 3.968*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:08:05. 552960 iterations done in 3.983*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:09:03. ... 782336 iterations done in 5.655*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:52:31. 784384 iterations done in 5.671*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 03:00:20. 786432 iterations done in 5.685*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:58:41. ... 907264 iterations done in 6.568*10^5 seconds. Should take 44.46 days or 3.841*10^6s, finish Thu 11 Oct 2018 04:26:21. 909312 iterations done in 6.583*10^5 seconds. Should take 44.46 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:29:41. 911360 iterations done in 6.598*10^5 seconds. Should take 44.47 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:33:53. ... 1028096 iterations done in 7.454*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:07:13. 1030144 iterations done in 7.470*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:11:43. 1032192 iterations done in 7.485*10^5 seconds. Should take 44.54 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:12:48.  A long-term power outage stopped this computation! # I so dearly want to see more digits of the MRB constant: Please, anyone, please help here!! Posted 4 years ago Would anyone let me know how this comes out on your computer? Here is a link to my Nov 16, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 18, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 19, 2018 update of calculating 4 million digits of MRB: HERE, Here is a link to my Nov 20, 2018 update of calculating 4 million digits of MRB: HERE Here is a link to my Nov 21, 2018 update of calculating 4 million digits of MRB: HERE Here is a link to my Nov 22, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 24, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Nov 27, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Dec 05, 2018 update of calculating 4 million digits of MRB: HERE. Here is a link to my Dec 10, 2018 update of calculating 4 million digits of MRB: HERE. ## Last update of 2018 5:37:20 pm EST | Monday, December 31, 2018 (49.04 days from start time), 75.2315 percent completed . 3,024,300 digits computed.3993600 iterations done in 4.23810^6 seconds. Should take 65.18 days or 5.63110^6s, finish Wed 16 Jan 2019 20:57:47. (16.64 days from now). ## Probably the last update 12:47:20 am EST | Monday, January 14, 2019 (62.3495 days from start time), 95.679 percent completed . 3,846,295 digits computed. 5079040 iterations done in 5.38710^6 seconds. Should take 65.15 days or 5.62910^6s, finish Wed 16 Jan 2019 20:13:07. (2.81 days from now). Posted 5 years ago  nice system! Posted 8 years ago  MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .Attachments are still here, though. Attachments: Posted 8 years ago  The MRB constant is now a Scholar subject: https://scholar.google.com/scholar?q=%22MRB+constant%22 Posted 8 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 8 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 8 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 8 years ago  I figured out how to rapidly compute AND CHECK a computation of the MRB constant! (The timing given is in processor time [for computing and checking] only. T0 can be used with another SessionTime[] call at the end to figure out all time expired during running of the program.) I used both of Crandall's methods for computing it and used for a check, the nontrivial identity ,where gamma is the Euler constant and M is the MRB constant.Below is my first version of the code with results. If nothing else, I thought, the code pits Crandall's 2 methods against each other to show if one is wrong they both are wrong. (So it is not a real proof.) But these are two totally different methods! (the first of which has been proven by Henry Cohen to be theoretically correct here). For a second check mm is a known approximation to the constant; over 3 million non checked (as of now) digits are found in the attached file 3M.nb. (You will have to change the Format/Style to Input to use the digits.) In[15]:= (*MRB constant computation with verification! The constant's \ decimal approximation is saved as MRBtest*)prec = 5000;(*Number of \ required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize;, {k, 0, end - 1}]; etaMs = N[-s/d - (EulerGamma Log[2] - Log[2]^2/2), pr]]; t2 = Timing[MRBtest2 = expM[prec];]; Print["The MRB constant was computed and checked to ", prec, " digits \ in ", t1 = t2[[1]] + Timing[eta[s_] := (1 - 2^(1 - s)) Zeta[s]; eta1 = Limit[D[eta[s], s], s -> 1]; MRBtrue = mm; MRBtest = eta1 + etaMs; check = MRBtest - MRBtrue][[1]], " seconds"]; check During evaluation of In[15]:= The MRB constant was computed and checked to 5000 digits in 2.12161 seconds Out[18]= 0.*10^-5000 In[19]:= MRBtest - mm Out[19]= 0.*10^-5000  Attachments: Posted 8 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 4 years ago

## 02/12/2019

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

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

SessionTime[] - to


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

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

## 3/28/2019

Here is an updated table of speed eta formula records:

## 04/03/2019

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

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

SessionTime[] - to

(* 0.*10^-50000

500808.4835750*)

Posted 4 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 8 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 8 years ago
 Crandall is not using his eta formulas directly!!!!!!! He computes Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}] directly!Going back to Crandall's code: (*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 500000;(*Number of \ required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]}, chunksize = cores*tsize; n = Floor[1.32 pr]; end = Ceiling[n/chunksize]; Print["Iterations required: ", n]; Print["end ", end]; Print[end*chunksize]; d = N[(3 + Sqrt[8])^n, pr + 10]; d = Round[1/2 (d + 1/d)]; {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0}; iprec = Ceiling[pr/27]; Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l; x = N[E^(Log[ll]/(ll)), iprec]; pc = iprec; While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll], pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, Method -> "EvaluationsPerKernel" -> 1]]; ctab = Table[c = b - c; ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); c, {l, chunksize}]; s += ctab.(xvals - 1); start += chunksize; Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0, end - 1}]; N[-s/d, pr]]; t2 = Timing[MRBtest2 = expM[prec];]; MRBtest2 - MRBtest3 x = N[E^(Log[ll]/(ll)), iprec]; Gives k^(1/k) to only 1 decimal place; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0).. On the other hand, While[pc < pr, pc = Min[3 pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x (1 - 2 y/((ll + 1) y + 2 ll ll));], takes the short precision x and gives it the necessary precision and accuracy for k^(1/k) (k Is ll there.) It actually computes k^(1/k). Then he remarks, "(N[Exp[Log[ll]/ll], pr])."After finding a fast way to compute k^(1/k) to necessary precision he uses Cohen's algorithm 1 (See a screenshot in a previous post.) to accelerate convergence of Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}]. That is his secret!!As I mentioned in a previous post the "MRBtest2 - MRBtest3" is for checking with a known-to-be accurate approximation to the MRB constant, MRBtest3I'm just excited that I figured it out! as you can tell.
Posted 8 years ago
 Nice work. Worth a bit of excitement, I' d say.
Posted 8 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 8 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 8 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 8 years ago

## Tue 24 Apr 2018

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

[41]

## Sat 28 Apr 2018

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

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

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

Here are the 3 programs referenced in the above table:

# All MRB:

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

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

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


# Crandall

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


# Hybrid

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


## Aug 8 2018

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

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

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


.

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

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

See attached "58 hour million."

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

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

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

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

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

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

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

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

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


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

Iterations required: 1326598

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Actual time was 192609.7247443

Enter MRBtest2 to print 1004992 digits

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


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

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

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

## 01/08/2019

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

Attachments:
Posted 9 years ago
 It is hard to be certain that c1 and c2 are correct to 77 digits even though they agree to that extent. I'm not saying that they are incorrect and presumably you have verified this. Just claiming that whatever methods NSum may be using to accelerate convergence, there is really no guarantee that they apply to this particular computation. So c1 aand c2 could agree to that many places because they are computed in a similar manner without all digits actually being correct.
Posted 9 years ago
 Perhaps some of these speed records will be easier to beat.The ultimate speed record to beat, though, is Ricahrd Crandall's (Chief cryptographer for Apple, 2012) 1,048,576 digits in a blistering fast 76.4 hours, while the Apple computation group(also in 2012) computed 1,000,000 digits of the MRB constant in a long 18 days 9 hours 11 minutes 34.253417 seconds, so progress vs time is not as linear as my results plotted above.
Posted 9 years ago

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

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

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

Posted 9 years ago
 This is the second post in the MRB constant discussion, so right above this, if you can see the number of viewsand the wordsReply | Flag at the same time,you might have to refresh the page to see the first message. The first message is crucial for understanding the MRB constant, as most of the facts are there. The following might help anyone serious about breaking my record.Richard Crandall wrote about couple of new formulae for computing the MRB constant faster on pp 28 and 29 here. By the way, I wrote Crandall about formula (44) -- it seems it should have a minus sign in front of it -- and he wrote back: