Message Boards Message Boards

GROUPS:

Try to beat these MRB constant records!

Posted 8 years ago
671151 Views
|
70 Replies
|
17 Total Likes
|

POSTED BY: Marvin Ray Burns.

An Easter egg for you to find below:

(In another reality, I invented CMRB and then discovered many of its qualities.)

Content of the first post, as of August 16, 2022

  1. My claim to the MRB constant (CMRB), or a case of calculus déjà vu?
  2. What exactly is it?
  3. Where is it found?
  4. Q and A,
  5. How it all began,
  6. The why and what of the CMRB Records,
  7. CMRB and its applications.

The following contents of the first post have been moved. Use CNRL+F to locate.

  1. CNRTL+F "Real-World, and beyond, Applications".
  2. CNRL+F "MeijerG Representation for" CMRB,
  3. CMRB CNRL+F "formulas and identities",
  4. CNRL+F "Primary Proof 1",
  5. CNRL+F "Primary Proof 2",
  6. CNRL+F "Primary Proof 3",
  7. CNRL+F "The relationship between" CMRB and its integrated analog,
  8. The MRB constant supercomputer 0

Second post:

The following might help anyone serious about breaking my record.

Third post

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

Fourth post

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

Many more interesting posts

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

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

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

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

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

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

...including arbitrarily close approximation formulas for CMRB.

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

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

...including CNRL+F "the Laplace transform analogy to" CMRB.

...including CNRTL+F "Real-World, and beyond, Applications".

... including an overview of all CMRB speed records, by platform.

...including 3 attempts at a spectacular 7 million digits using Mathematica.





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

Amateurs have been known to make a few significant discoveries as discussed in enter image description here here. This amateur has made his best attempts at proving his discoveries and has often asked for help in doing so. Great thanks to all of those who offered a hand! If I've failed to give you credit for any of your suggestions, let me know and I will correct that issue!

As I went more and more public with my discoveries, I made several attempts to see what portion of them was original. What I concluded from these investigations was that the only original thought I had was the obstinacy to think anything meaningful can be found in the infinite sum shown next. CMRB sum Nonetheless, it is possible that someone might have a claim to this thought to whom I have not given proper credit. If that is you I apologize. The last thing we need is another calculus war, this time for a constant. However, if your thought was published after mine, as Newton said concerning Leibniz's claim to calculus, “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]

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

enter image description here

If you see this instead of an image, reload the page.enter image description here

(the calculus war for CMRB)

CREDIT

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

LATIN

PRINCIPIS CMRB MATHEMATICA

ACTA CMRB ERUDITORUM

ENGLISH

PRINCIPLES OF CMRB MATHEMATICS

REPORTS OF CMRB SCHOLARS

MATH

enter image description here

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

enter image description here

( 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,

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

[sic] they created a new system, like as many series have been studied for centuries leading to a labyrinth of sums, I opened up a channel for the CMRB "realities."

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.



CMRB

=

enter image description here and from Richard Cradall in 2012 courtesy of Apple Computer's advanced computational group we have the following:

enter image description here

Eta denotes the kth 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.}*)

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

n^(1/n)-1

At enter image description here here, we have the following explanation.

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

So, by definition the MRB constant $B$ is the conditionally convergent sum $\sum_{n \geq 1} (-1)^n (n^{1/n} - 1)$. Put $a_n = (-1)^n (n^{1/n}= - 1)$,

so $B = \sum_{n \geq 1} a_n.$

Looking at the first column, put $b_n = (-1)^n \frac{\log(n)}{n}.$

so $\eta^{(1)}(1) = \sum_{n \geq 1}> b_n$

as a conditionally convergent series.

We have

$$B - \eta^{(1)} = \sum_{n \geq 1} a_n - b_n = \sum_{n \geq 1} \sum_{m \geq 2} (-1)^n \frac{(\log n)^m}{n^m m!}$$

(The first equation is an elementary limit statement that says if $\sum_{n \geq 1} a_n$ converges and $\sum_{n \geq 1} b_n$ converges, then also $\sum_{n \geq 1} a_n - b_n$ converges and $\sum_{n \geq 1} a_n - \sum_{n \geq 1} b_n = \sum_{n \geq 1} a_n - b_n$. It doesn't at all matter whether the convergence of either series is conditional or absolute.)

So now we check the absolute convergence of the right-hand side, i.e., that $\sum_{n \geq 1} \sum_{m \geq 2} \frac{(\log n)^m}{n^m m!}$ converges. (Remember what this means in the case of infinite sums of positive terms: it means that there is a number $K$ such that every finite partial sum $S$ is bounded above by $K$; the least such upper bound will be the number that the infinite sum converges to.) So take any such finite partial sum $S$, and rearrange its terms so that the terms in the $m = 2$ column come first, then the terms in the $m = 3$ column, and so on. An upper bound for the terms of $S$ in the $m = 2$ column is $\frac{\zeta^{(2)}(2)}{2!}$. Put that one aside.

For the $m = 3$ column, an upper bound is $\sum_{n \geq 2} \frac{(\log n)^3}{n^3 3!}$ (we drop the $n=1$ term which is $0$). By calculus we have $\log n \leq n^{1/2}$ for all $n \geq 2$, so this has upper bound $\frac1{3!} \sum_{n \geq 2} \frac1{n^{3/2}} \leq \frac1{3!} \int_1^\infty \frac{dx}{x^{3/2}}$ by an integral test, which yields $\frac{2}{3!}$ as an upper bound. Applying the same reasoning for the $m$ column from $m = 4$ on, an upper bound for that column would be $\frac1{m!} \int_1^\infty \frac{dx}{x^{m/2}} = \frac{2}{m!(m-2)}$. Adding all those upper bounds together, an upper bound for the entire doubly infinite sum would be

$$\frac{\zeta^{(2)}(2)}{2!} + \sum_{m \geq 3} \frac{2}{m!(m-2)}$$

which certainly converges. So we have absolute convergence of the doubly infinite sum.

Thus we are in a position to apply the Fubini theorem, which justifies the rearrangement expressed in the first of the following equations

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

giving us what we wanted.


it is defined in all of the following places, most of which attribute it to my curiosity:


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 the MRB constant?

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:

There is nothing without a reason.

Read more at: https://minimalistquotes.com/gottfried-leibniz-quote-229585/




How it all began

From these meager beginnings: My life has proven that one's grades in school are not necessarily a prognostication of achievement in mathematics. For evidence of my poor grades see my report cards.

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

Why I started so slow and am now a pioneer is a mystery! Could it say something about the educational system? Can the reason be found deep in psychology? (After all, I never made any progress in math or discoveries without first assuming I could, even when others were telling me, I couldn't!) Or could it be that the truth is a little of both and more?



From these meager beginnings:

On January 11 and 23,1999 I wrote,

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

The point is that I 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 my eye. So I carefully "brought it up" to a level of maturity, and my own understanding of math along with it! (In another reality, I invented CMRB and then discovered many of its qualities.)

In doing so, I came to find out that this constant (CMRB)

MRB math world snippit

(from https://mathworld.wolfram.com/MRBConstant.html)

was more closely related to other constants than I could have 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 conveniently construed constructions (half-hazardously put together formulas) that a naïve use of numeric search engines like Wolfram Alpha or the OEIS, might give, I 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 its relationship to Viswanath's constant (VC)

Viswanath' math world snippit

(from https://mathworld.wolfram.com/RandomFibonacciSequence.html)

With both being functions of x1/x alone, we have these near-zeors of VC using CMRB, which have a ratio of Gelfond's constant $=e^\pi.$ =e^\pi Notice, by "near-zeros," I mean we have the following. near-zeros

VC/(6*(11/7 - ProductLog[1])) - CMRB
CMRB - (5*VC^6)/56

3.4164*10^-8

1.47*10^-9

Out[54]= 3.4164*^-8

Out[55]= 1.47*^-9

See cloud notebook.



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

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



From these meager beginnings:

On Feb 22, 2009, I wrote,

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

enter image description here

I came to find out my 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=hypothesis

Which is the same as

enter image description here 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 .

Iimofg->1

Cauchy's Integral Theorem

Lim surface h gamma r=0

Lim surface h beta r=0

limit to 2n-1

limit to 2n-

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

leftright

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

enter image description here

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

enter image description here

M1 has a convergent series, enter image description here 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. And where

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

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

big plot small plot


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

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

o$

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 enter image description here

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

Whileenter image description here enter image description here

enter image description here


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

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

(digits and seconds)

enter image description here Better 2022 results are expected soon!

2022 results documentation:



From these meager beginnings:

In October 2016, I wrote the following here in researchgate:

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

ratio of a-1 to a

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 a proof of 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:

L’ Hospital’s a's

(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 there is no limit a goes to infinity, of the ratio of the previous forms of integrals when the "I" is left out, and give a small proof for their divergence.

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

enter image description here


From these meager beginnings:

In November 2013, I 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 me to ask what value of $a$ gives $$\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-a)=0\text{ ?}$$(For what value of a is the Levin's u-transform's and Cesàro's sum result 0 considering weak convergence?)

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

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

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.

Finally let a = M2 = $1-2\times C$MRB = 0.6242807150758... and the two limit-points of the series $\sum_{n=1}^\infty (-1)^n\times(n^{1/n}-M2)$ are +/- $C$MRB with its Levin's u-transform's result being 0. See here.

Also,

enter image description here




Scholarly works about CMRB.

From these meager beginnings:

In 2015 I 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. And they almost all instantly collapsed, as far as our sensory realm is concerned, leaving all but the few we enjoy today.

I'm not the first person to think the universe consists of an infinitude of dimensions. Some string theories and theorists propose it too. Michele Nardelli added the following.

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

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

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

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

--

Analyzing several equations concerning Geometric Measure Theory, various Ramanujan parameters and the developments of the MRB Constant. New possible mathematical connections with some sectors of String Theory. XII

--

On several equations concerning Geometric Measure Theory, various Ramanujan parameters and the developments of the MRB Constant. New possible mathematical connections with some sectors of Cosmology (Bubble universes) and String Theory

--

Analyzing several equations concerning Geometric Measure Theory, various Ramanujan parameters and the developments of the MRB Constant. New possible mathematical connections with some sectors of Cosmology (Bubble universes) and String Theory. III

--

Analyzing several equations concerning Geometric Measure Theory, various Ramanujan parameters and the developments of the MRB Constant. New possible mathematical connections with some equations concerning various aspects of Quantum Mechanics and String Theory. VI

--

Analyzing several equations concerning various aspects of String Theory and one-loop graviton correction to the conformal scalar mode function. New possible mathematical connections with various Ramanujan parameters and some developments of the MRB Constant.

--

Analyzing several equations concerning Geometric Measure Theory, various Ramanujan parameters and the developments of the MRB Constant. New possible mathematical connections with some equations concerning Multiverse models and the Lorentzian path integral for the vacuum decay process

--

On the study of various equations concerning Primordial Gravitational Waves in Standard Cosmology and some sectors of String Theory. New possible mathematical connections with various Ramanujan formulas and various developments of the MRB Constant

--

On the study of some equations concerning the mathematics of String Theory. New possible connections with some sectors of Number Theory and MRB Constant

--

On the study of some equations concerning the mathematics of String Theory. New possible connections with some sectors of Number Theory and MRB Constant. II

--

Analyzing some equations of Manuscript Book 2 of Srinivasa Ramanujan. New possible mathematical connections with several equations concerning the Geometric Measure Theory, the MRB Constant and various sectors of String Theory

--

Analyzing the MRB Constant in Geometric Measure Theory and in a Ramanujan equation. New possible mathematical connections with ζ(2), ϕ , the Quantum Cosmological Constant and some sectors of String Theory

--

Analyzing some equations of Manuscript Book 2 of Srinivasa Ramanujan. New possible mathematical connections with several equations concerning the Geometric Measure Theory, the MRB Constant, various sectors of Black Hole Physics and String Theory

--

Analyzing further equations of Manuscript Book 2 of Srinivasa Ramanujan. New possible mathematical connections with the MRB Constant, the Ramanujan-Nardelli Mock General Formula and several equations concerning some sectors of String Theory III

His latest papers on the MRB constant, follow.

Hi Marvin, for me the best links you could post are those related to the works concerning the Ramanujan continued fractions and mathematical connections with MRB Constant and various sectors of String Theory.

Here are the links (in all there are 40):

https://www.academia.edu/80247977/ https://www.academia.edu/80298701/ https://www.academia.edu/80376615/ https://www.academia.edu/80431963/ https://www.academia.edu/80508286/ https://www.academia.edu/80590932/ https://www.academia.edu/80660709/ https://www.academia.edu/80724379/ https://www.academia.edu/80799006/ https://www.academia.edu/80894850/ https://www.academia.edu/81033980/ https://www.academia.edu/81150262/ https://www.academia.edu/81231887/ https://www.academia.edu/81313294/ https://www.academia.edu/81536589/ https://www.academia.edu/81625054/ https://www.academia.edu/81705896/ https://www.academia.edu/81769347/ https://www.academia.edu/81812404/ https://www.academia.edu/81874954/ https://www.academia.edu/81959191/ https://www.academia.edu/82036273/ https://www.academia.edu/82080277/ https://www.academia.edu/82129372/ https://www.academia.edu/82155422/ https://www.academia.edu/82204999/ https://www.academia.edu/82231273/ https://www.academia.edu/82243774/ https://www.academia.edu/82347058/ https://www.academia.edu/82399680/ https://www.academia.edu/82441768/ https://www.academia.edu/82475969/ https://www.academia.edu/82516896/ https://www.academia.edu/82521506/ https://www.academia.edu/82532215/ https://www.academia.edu/82622577/ https://www.academia.edu/82679726/ https://www.academia.edu/82733681/ https://www.academia.edu/82777895/ https://www.academia.edu/82828901/

He recently added the following.

Hi Marvin,

The MRB Constant, also in the case of the Ramanujan's expressions that we are slowly analyzing, serves to "normalize", therefore to rectify the approximations we obtain. For example, for the value of zeta (2), which is always approximate (1.64382 ....)" [from the string theory equations, example below], "adding an expression containing the MRB Constant gives a result much closer to the real value which is 1.644934 ... This procedure is carried out on all those we call "recurring numbers" (Pi, zeta (2), 4096, 1729 and the golden ratio), which, developing the expressions, are always approximations, from which, by inserting the CMRB in various ways, we obtain results much closer to the real values of the aforementioned recurring numbers. Finally, remember that Ramanujan's expressions and the recurring numbers that are obtained are connected to the frequencies of the strings, therefore to the vibrations of the same.

One example of his procedure from https://www.academia.edu/81812404/OnfurtherRamanujanscontinuedfractionsmathematicalconnectionswithMRBConstantvariousequationsconcerningsomesectorsofStringTheoryXIX?

was to analyze some expressions from Ramanujan's notebooks.

Finding other expressions from series of their anti-derivative and derivatives, in this case, dividing two previous expressions, after some calculations, he obtained this expression from it."

enter image description here

Then finally "by inserting the CMRB, obtaining results much closer to the real values of the aforementioned recurring numbers:" (referring to Ramanujan's equation, and the after more work..)

, enter image description here

You need to look at the paper entirely to see how he puts it all together. He uses Wolfram Alpha for a lot of it.

7/7/2022 I just found a video he made concerning his work on string theory with its connection to Ramanujan and CMRB. English subtitles are available on youtube.


More Google Scholar results on CMRBt are here, which include the following.

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

enter image description here

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.





MRB Constant Records,

My inspiration to compute a lot of digits of CMRB came from the following website by Simon Plouffe.

There, computer mathematicians calculate millions, then billions of digits of constants like pi, when with only 65 decimal places of pi, we could determine the size of the observable universe to within a Planck length (where the uncertainty of our measure of the universe would be greater than the universe itself)!

In contrast 65 digits of the MRB constant "measures" the value of -1+ssqrt(2)-3^(1/3) up to n^(1/n) where n is 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000, which can be called 1 unvigintillion or just 10^66.

And why compute 65 digits of the MRB constant? Because 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!!!)

enter image description here enter image description here enter image description here enter image description here

So, below you find reproducible results with methods. The utmost care has been taken to assure the accuracy of the record number of digits calculations. These records represent the advancement of consumer-level computers, 21st century Iterative methods, and clever programming over the past 23 years.

Here are some record computations of CMRB. If you know of any others let me know, and I will probably add them!

1 digit of the (additive inverse of ) **C**<sub>*MRB*</sub> with my TI-92s, by adding 1-sqrt(2)+3^(1/3)-4^(1/4)+... as far as I could, was computed. That first digit, by the way, was just 0. Then by using the sum key, to compute $\sum _{n=1}^{1000 } (-1)^n \left(n^{1/n}\right),$  the first correct decimal of $\text{CMRB}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right)$ i.e. (.1). It gave (.1_91323989714) which is close to what Mathematica gives for summing to only an upper limit of 1000. 

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

5 correct decimals (rounded to .18786), in Jan of 1999 were drawn from CMRB using Mathcad 3.1 on a 50 MHz 80486 IBM 486 personal computer operating on Windows 95.

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

 500 digits of CMRB with an online tool called Sigma on Jan 23, 1999. See [http://marvinrayburns.com/Original_MRB_Post.html][130]   if you can read the printed and scanned copy there.

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, I did it 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. *)

PII 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, I did it in <2.5 seconds on the MRBCSC 3 on July 7, 2022 (more than 14,400 times as fast!)

PIII 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. Max memory used was 4.0 GB of RAM.

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

100,000 digits of CMRB on Aug 12, 2007, at 8:00 PM EST, were computed in 170 hours on a 2.66 GHz Core 2 Duo using 64-bit Windows XP. Max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.
To beat that, on the 4th of July, 2022, I computed the same digits in  1/4 of an hour. CNTRL+F "4th of July, 2022" for documentation.
To beat that, on the 7th of July, 2022, I computed the same digits in  1/5 of an hour. CNTRL+F "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. Max memory used was 22 GB of RAM. The typical daily record of memory used was 17 GB of RAM.

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

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

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

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

250,000 digits were attempted but failed to be completed to a serious internal error that restarted the machine. The error occurred sometime on December 24, 2008, between 9:00 AM and 9:00 PM. The computation began on November 16, 2008, at 10:03 PM EST. The Max memory used was 60.5 GB.

 250,000 digits of CMRB on Jan 29, 2009, 1:26:19 pm (UTC-0500) EST, with a multiple-step Mathematica command running on a dedicated 64-bit XP using 4 GB DDR2 RAM onboard and 36 GB virtual. The computation took only 333.102 hours. The digits are at http://marvinrayburns.com/250KMRB.txt. The computation is completely documented.

  300000 digit search of CMRB was initiated using an i7 with 8.0 GB of DDR3 RAM onboard on Sun 28 Mar 2010 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. I used Mathematica 6.0 for Microsoft Windows (64-bit) (June 19, 2007) Which is an average of 7.44 seconds per digit. I used my Dell Studio XPS 8100 i7 860 @ 2.80 GHz with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929 GB virtual Ram.

300,000 digits to the right of the decimal point of CMRB from Sat 8 Oct 2011 23:50:40 to Sat 5 Nov 2011 19:53:42 (2.405*10^6 seconds later). This run was 0.5766 seconds per digit slower than the 299,998 digit computation even though it used 16 GB physical DDR3 RAM on the same machine. The working precision and accuracy goal combination were maximized for exactly 300,000 digits, and the result was automatically saved as a file instead of just being displayed on the front end. Windows reserved a total of 63 GB of working memory of which 52 GB were recorded being used. The 300,000 digits came from the Mathematica 7.0 command`
    Quit; DateString[]
    digits = 300000; str = OpenWrite[]; SetOptions[str, 
    PageWidth -> 1000]; time = SessionTime[]; Write[str, 
    NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, 
    WorkingPrecision -> digits + 3, AccuracyGoal -> digits, 
    Method -> "AlternatingSigns"]]; timeused = 
    SessionTime[] - time; here = Close[str]
    DateString[]

314159 digits of the constant took 3 tries due to hardware failure. Finishing on September 18, 2012, I computed 314159 digits, taking 59 GB of RAM.  The digits came from the Mathematica 8.0.4 code`

    DateString[]
    NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, 
    WorkingPrecision -> 314169, Method -> "AlternatingSigns"] // Timing
    DateString[]

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

1,048,576 digits 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's on a 2.93 GHz 8-core Nehalem.

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

    To beat that, I accumulated over 1,004,993 correct digits 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 I did 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 of the 30 cores were clocked at up to 5.2 GHz.

    To beat that I did a 1,004,993 correct digits computation in 35.6 hours of absolute time and only 25.3 hours of computation time, on Wed 3 Aug 2022 08:05:38, using the MRB constant supercomputer 3. Ram Speed was 4000MHz and all of the 40 cores were clocked at up to 5.5 GHz.

44 hours million notebook

36.7 hours million notebook

35.6 hours million notebook


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

 3,014,991 digits of CMRB,  world record computation of **C**<sub>*MRB*</sub> was finished on Sun 21 Sep 2014 at 18:35:06. It took 1 month 27 days 2 hours 45 minutes 15 seconds. The processor time from the 3,000,000+ digit computation was 22 days. I computed the 3,014,991 digits of **C**<sub>*MRB*</sub> with Mathematica 10.0. I Used my new version of Richard Crandall's code in the attached 3M.nb, optimized for my platform and large computations. I also used a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz with 64 GB of RAM of which only 16 GB was used. Can you beat it (in more number of digits, less memory used, or less time taken)? This confirms that my previous "2,000,000 or more digit computation" was accurate to 2,009,993 digits. they were used to check the first several digits of this computation. See attached 3M.nb for the full code and digits.

 Over 4 million digits of CMRB was finished on Wed 16 Jan 2019 19:55:20.
It took 4 years of continuous tries. This successful run took 65.13 days absolute time, with a processor time of 25.17 days, on a 3.7 GHz overclocked up to 4.7 GHz on all cores Intel 6 core computer with 3000 MHz RAM. According to this computation, the previous record, 3,000,000+ digit computation, was accurate to 3,014,871 decimals, as this computation used my algorithm for computing n^(1/n) as found in chapter 3 in the paper at 

https://www.sciencedirect.com/science/article/pii/0898122189900242 and the 3 million+ computation used Crandall's algorithm. Both algorithms outperform Newton's method per calculation and iteration.


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

ClearSystemCache[]; n = 123456789;
(*n is the n in n^(1/n)*)
x = N[n^(1/n),100];
(*x starts out as a relatively small precision approximation to n^(1/n)*)
pc = Precision[x]; pr = 10000000;
(*pr is the desired precision of your n^(1/n)*)
Print[t0 = Timing[While[pc < pr, pc = Min[4 pc, pr];
x = SetPrecision[x, pc];
y = x^n; z = (n - y)/y;
t = 2 n - 1; t2 = t^2;
x = x*(1 + SetPrecision[4.5, pc] (n - 1)/t2 + (n + 1) z/(2 n t)
- SetPrecision[13.5, pc] n (n - 1)/(3 n t2 + t^3 z))];
(*You get a much faster version of N[n^(1/n),pr]*)
N[n - x^n, 10]](*The error*)];
ClearSystemCache[]; n = 123456789; Print[t1 = Timing[N[n - N[n^(1/n), pr]^n, 10]]]

 Gives

  {25.5469,0.*10^-9999984}

  {101.359,0.*10^-9999984}




  More information is available upon request.

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

6,000,000 digits of CMRB after 8 tries in 19 months. (Search "8/24/2019 It's time for more digits!" below.) finishing on Tue 30 Mar 2021 at 22:02:49 in 160 days.
    The MRB constant supercomputer 2 said the following:
    Finished on Tue 30 Mar 2021 22:02:49. computation and absolute time were
    5.28815859375*10^6 and 1.38935720536301*10^7 s. respectively
    Enter MRB1 to print 6029991 digits. The error from a 5,000,000 or more-digit calculation that used a different method is      
    0.*10^-5024993.

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

5,609,880, verified by 2 distinct algorithms for x^(1/x), digits of 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
calculation that used a different method is 
0.*10^-6029992.

"Computation time" 72.526 days

 "Absolute time" 185.491 days







CMRB and its applications

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

From Wikipedia:

If you see this instead of an image, reload the page If you see this instead of an image, reload the page

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

`

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

enter image description here

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

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

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

enter image description here

Code:

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

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

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

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

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

From MathWorld:

MathWorld MRB MathWorld MRB 2

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

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

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

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

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

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


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

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

enter image description here

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

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

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

Skenter image description here which, since the sum of the absolute values of the summands is finite, the sum converges absolutely!

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

enter image description here enter image description here





Real-World, and beyond, Applications

This section and the rest of the content of this first post were moved below to improve loading times. CNRL+F "Real-World, and beyond, Applications" to finish reading it.

POSTED BY: Marvin Ray Burns
70 Replies

This is the second post in the MRB constant discussion, so right above this, if you can see the header

and the words

Reply | 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. a true jewel of an expression Interestingly, as pointed out by J. Borwein,

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: enter image description here

POSTED BY: Marvin Ray Burns

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

Reply|Flag

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: enter image description here

POSTED BY: Marvin Ray Burns

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

enter image description here

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 BY: Marvin Ray Burns

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 BY: Daniel Lichtblau

For c1 I used a method for alternating series to get a very precise sum approximation: That is from the "AlternatingSigns" option.

POSTED BY: Marvin Ray Burns

C1, the approximation to enter image description hereand a special case of enter image description here, is computed correctly by Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier,s Convergence Acceleration of Alternating Series as found next.

enter image description hereenter image description here

Below it is computed by Newton's method using their acceleration "Algorithm 1" to at least 1000 decimals.

  (* Newer loop with Newton interior. *)
 prec = 1000;(*Number of required decimals.*)
 expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.32 pr];
   Print["Iterations required: ", n];
   d = N[(3 + Sqrt[8])^n, pr + 10];
   d = Round[1/2 (d + 1/d)];
   {b, c, s} = {-1, -d, 0};
   T0 = SessionTime[];
   Do[c = b - c;
    x = N[E^(Log[k + 1]/(k + 1)), iprec = Ceiling[prec/128]];
    pc = iprec;
    Do[nprec = Min[2 pc, pr];
     x = SetPrecision[x, nprec];(*Adjust precision*)
     x = N[x - x/(k + 1) + 1/x^k, nprec];
     pc *= 2;
     If[nprec >= pr, Break[]], {ct, 1, 19}];
    s += c*(x - 1);
    b *= 2 (k + n) (k - n)/((k + 1) (2 k + 1));
    If[Mod[k, 1000] == 0, 
     Print["Iterations: ", k, "    Cumulative time (sec): ", 
       SessionTime[] - T0];], {k, 0, n - 1}];
   N[-s/d, pr]];

 MRBtest2 = expM[prec]

During evaluation of In[17]:= Iterations required: 1320

During evaluation of In[17]:= Iterations: 0 Cumulative time (sec): 0.*10^-8

During evaluation of In[17]:= Iterations: 1000 Cumulative time (sec): 0.1872004

Out[18]= 0. 1878596424620671202485179340542732300559030949001387861720046840894772 3156466021370329665443310749690384234585625801906123137009475922663043 8929348896184120837336626081613602738126379373435283212552763962171489 3217020762820621715167154084126804483635416719985197680252759893899391 4457983505561350964852107120784442309586812949768852694956420425558648 3670441042527952471060666092633974834103115781678641668915460034222258 8380025455396892947114212218910509832871227730802003644521539053639505 5332203470627551159812828039510219264914673176293516190659816018664245 8249506972033819929584209355151625143993576007645932912814517090824249 1588320416906640933443591480670556469280678700702811500938060693813938 5953360657987405562062348704329360737819564603104763950664893061360645 5280675151935082808373767192968663981030949496374962773830498463245634 7931157530028921252329181619562697369707486576547607117801719578736830 0965902260668753656305516567361288150201438756136686552210674305370591 0397357561914891

They are the same as found from the methods Mathematica uses:

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

0.18785964246206712024851793405427323005590309490013878617200468408947 723156466021370329665443310750

POSTED BY: Marvin Ray Burns

One more record, Richard Crandall was the first one to compute 319,000 digits of the MRB constant in one day*, as early as Nov 24, 2012. Here is a portion of his email:

enter image description here

*He may have been counting CPU time alone (from the Timing[] comand which is an under estimate of the actual time taken).. My personal records are in actual time taken.

POSTED BY: Marvin Ray Burns

Tue 24 Apr 2018

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

enter image description here[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!:

enter image description here

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:

table

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["SubKernels`LocalKernels`"]
 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:

top bottom

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): enter image description here Notice, I broke the 1,000 second mark!!!!!

Attachments:
POSTED BY: Marvin Ray Burns

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 BY: Daniel Lichtblau

Daniel Lichtblau,
Which one do you not understand? how he derived the eta' formula:enter image description here from enter image description here?

Or is it how and why he added the extra loop to Cohen's method:`

ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); ?`

I've been asking for a proof of the eta formula derivation. I think it could become the foundation to a great paper.

If the extra loop changes Cohen's method for enter image description here to a method for enter image description hereI think the code in that loop could help prove the derivation.

POSTED BY: Marvin Ray Burns

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 BY: Daniel Lichtblau

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: enter image description here

POSTED BY: Marvin Ray Burns

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, MRBtest3

I'm just excited that I figured it out! as you can tell.

POSTED BY: Marvin Ray Burns

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

POSTED BY: Daniel Lichtblau

Richard Crandall might of had some help in developing his method. He wrote one time:

"Marvin I am working on a highly efficient method for your constant, and I've been in touch with other mathematics scholars.

Please be patient...

rec

Sent from my iPhone."

POSTED BY: Marvin Ray Burns

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:

enter image description here

I computed and checked 500 digits, using the first eta derivative formula in 38.6 seconds. How well can you do? Can you improve my program? (It is a 51.4% improvement of one of Crandall's programs.) I would like a little competition in some of these records! (That formula takes just 225 summands, compared to 10^501 summands using -1^(1/1)+2^(1/2)-3^(1/3)+.... See http://arxiv.org/pdf/0912.3844v3.pdf for more summation requirements for other summation methods.)

In[37]:= mm = 
  0.187859642462067120248517934054273230055903094900138786172004684089\
4772315646602137032966544331074969038423458562580190612313700947592266\
3043892934889618412083733662608161360273812637937343528321255276396217\
1489321702076282062171516715408412680448363541671998519768025275989389\
9391445798350556135096485210712078444230958681294976885269495642042555\
8648367044104252795247106066609263397483410311578167864166891546003422\
2258838002545539689294711421221891050983287122773080200364452153905363\
9505533220347062755115981282803951021926491467317629351619065981601866\
4245824950697203381992958420935515162514399357600764593291281451709082\
4249158832041690664093344359148067055646928067870070281150093806069381\
3938595336065798740556206234870432936073781956460310476395066489306136\
0645528067515193508280837376719296866398103094949637496277383049846324\
5634793115753002892125232918161956269736970748657654760711780171957873\
6830096590226066875365630551656736128815020143875613668655221067430537\
0591039735756191489093690777983203551193362404637253494105428363699717\
0244185516548372793588220081344809610588020306478196195969537562878348\
1233497638586301014072725292301472333336250918584024803704048881967676\
7601198581116791693527968520441600270861372286889451015102919988536905\
7286592870868754254925337943953475897035633134403826388879866561959807\
3351473990256577813317226107612797585272274277730898577492230597096257\
2562718836755752978879253616876739403543214513627725492293131262764357\
3214462161877863771542054231282234462953965329033221714798202807598422\
1065564890048536858707083268874877377635047689160983185536281667159108\
4121934201643860002585084265564350069548328301205461932`1661.\
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

enter image description here

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 BY: Marvin Ray Burns

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: eta records 12 31 18

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 BY: Marvin Ray Burns

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: enter image description here, 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.

eta 18 to19 n 2.JPG

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. enter image description here

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.

enter image description here

 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.

enter image description here

 MRBeta1 = EulerGamma Log[2] - 1/2 Log[2]^2

 EulerGamma Log[2] - Log[2]^2/2

enter image description here

   N[MRBeta2toinf + MRBeta1 - MRB, 10]

   1.307089967*10^-99742
POSTED BY: Marvin Ray Burns

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 identityenter image description here ,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 BY: Marvin Ray Burns

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 BY: Daniel Lichtblau

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=`enter image description here 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 enter image description here I wonder why he chose it?

POSTED BY: Marvin Ray Burns

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 BY: Daniel Lichtblau

The MRB constant is now a Scholar subject:

https://scholar.google.com/scholar?q=%22MRB+constant%22

POSTED BY: Marvin Ray Burns

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

enter image description here

Attachments are still here, though.

Attachments:
POSTED BY: Marvin Ray Burns
Posted 4 years ago

nice system!

POSTED BY: l van Veen

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 BY: Marvin Ray Burns

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 BY: Marvin Ray Burns

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 BY: Marvin Ray Burns

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["SubKernels`LocalKernels`"]
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.

POSTED BY: Marvin Ray Burns

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

3 node MRB Digital Storm 2

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

enter image description here

Attachments:
POSTED BY: Marvin Ray Burns

8/24/2019 It's time for more digits!

Using the 3 node MRB constant supercomputer, I started the 6 million digit computation of the MRB constant.

For some unknown reason, the kernel closed at 9:09:35 pm EDT | Saturday, August 31, 2019.

I can't stand not trying to make progress!!!! so I started the 6 million digits run again. More info coming soon!

Start time is Mon 16 Sep 2019 15:35:29.
POSTED BY: Marvin Ray Burns

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:

enter image description here enter image description here 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.

POSTED BY: Marvin Ray Burns

Well, my internet went out!!!!! To get it working, I had to reset my router. This killed the computation at 44% at 8:17:42 am EST | Thursday, November 28, 2019. I attached the notebook showing all of my progress.

Attachments:
POSTED BY: Marvin Ray Burns

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=enter image description here.

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.

enter image description here enter image description here

POSTED BY: Marvin Ray Burns

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

enter image description here

Here is the code:

First, compute 10,000 digits using Mathematica's "AlternatingSigns" option.

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

Then compute the integral.

Timing[mi = 
NIntegrate[
Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + 
t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 
2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 5000, 
Method -> "Trapezoidal", PrecisionGoal -> 10000, 
MaxRecursion -> 50]]

It is still working now on 2/26/2020 at 6:05 pm.

I messed up, but I'll let the computation complete anyway.

(My integral's result will only have around 5000 digits of precision -- so I should expect it to only be that accurate when I compare it to the sum.) But, this computation will give the approximate time required for a 10,000 digit calculation with that MaxRecursion (which might be way more than enough!)

It is still running at 7:52 am on 2/27/2020. The computer has been running at right around 12 GB of RAM committed and 9 GB of RAM in use, since early in the computation.

I started a second calculation on a similar computer. This one will be faster and give us a full 10,000 digits. But I reduced the MaxRecursion somewhat significantly. We'll see if all 10 k digits are right...

code

Timing[mi = 
  NIntegrate[
   Csch[\[Pi] t] E^((t ArcTan[t])/(1 + t^2)) (1 + 
       t^2)^(1/(2 + 2 t^2)) Sin[(2 ArcTan[t] - t Log[1 + t^2])/(2 + 
        2 t^2)], {t, 0, \[Infinity]}, WorkingPrecision -> 10000, 
   Method -> "Trapezoidal", PrecisionGoal -> 10000, 
   MaxRecursion -> 35]]

That lower threshold for MaxRecursion worked just fine!!!!!!!!!!!!!!! It took only 7497.63 seconds (roughly 2 hours) to calculate 10,000 accurate digits of the MRB constant from the integral.

2/27/2020 at 9:15 PM:

I just now started15,000 and a 20,000 digit computations of the integral form of the MRB constant. The 15,000 digit calculation of the MRB constant through the integral,enter image description here 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

enter image description here and enter image description here 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. enter image description here

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.

POSTED BY: Marvin Ray Burns

In 38 1/2 days, I computed 100,000 digits of the MRB constant from the enter image description here

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 BY: Marvin Ray Burns

4th Try at 6,000,000 (6 million) Digits

I thought about waiting to see if I was successful to 30% completion before posting about my new effort, but being isolated, I kinda need someone to talk to, so here's the code and results so far:

Start time is Wed 18 Mar 2020 21:14:14.

 ...

796672 iter. done in 8.647*10^5 s. Ave. 0.92134iter./s. Should take 99.990 days or 8.639*10^6s. Finish Fri 26 Jun 2020 20:59:28.

{10,% done.}
...
POSTED BY: Marvin Ray Burns

5th Try at 6,000,000 (6 million) Digits

The internet connection between my computers went out again!

I guess I'll have to use just one computer and calculate my 6,000,000 digits the slow way.

Well, at least this MRB records posting has reached a milestone of over 120,000 views on 3.31.2020, around 4:00 am.

So I restarted the computation on a single computer.

I'm using basically the same code as before.

Here are the most recent results at 9:12:15 pm EDT | Friday, May 1, 2020:

1409024 iter.done in 2.71910^6 s.Ave.0.51820 iter./s.It should take 177.78 days or 1.53610^7 s. Finish Fri 25 Sep 2020. 04 : 37 : 56.

N[1409024/ 7960576  *100] "percent done"

17.7 "percent done"

POSTED BY: Marvin Ray Burns

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, M=integral

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

m-int/m-int

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

etopi

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 BY: Marvin Ray Burns

m=the MRB constant. We looked at how n^m-m is similar to E^Pi-Pi (a near integer). One might think this is off the subject of breaking computational records of the MRB constant, but it also could help show whether there exists a closed-form for computing and checking the digits of m from n^m-m=a near integer and n is an integer.

So, I decided to make an extremely deep search of the n^m-m=a near integer, and n is an integer field. Here are the pearls I gleaned:

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

In[63]:= 225897077238546^m - m

Out[63]= 496.99999999999999975304752932252481772179797865

In[62]:= 1668628852566227424415^m - m

Out[62]= 9700.9999999999999999994613109586919797992822178

In[61]:= 605975224495422946908^m - m

Out[61]= 8019.9999999999999999989515156294756517433387956

In[60]:= 3096774194444417292742^m - m

Out[60]= 10896.0000000000000000000000096284579090392932063

In[56]:= 69554400815329506140847^m - m

Out[56]= 19549.9999999999999999999999991932013520540825206

In[68]:= 470143509230719799597513239^m - m

Out[68]= 102479.000000000000000000000000002312496475978584

In[70]:= 902912955019451288364714851^m - m

Out[70]= 115844.999999999999999999999999998248770510754951

In[73]:= 2275854518412286318764672497^m - m

Out[73]= 137817.000000000000000000000000000064276966095482

In[146]:= 2610692005347922107262552615512^m - m

Out[146]= 517703.00000000000000000000000000000013473353420

In[120]:= 9917209087670224712258555601844^m - m

Out[120]= 665228.00000000000000000000000000000011062183643

In[149]:= 19891475641447607923182836942486^m - m

Out[149]= 758152.00000000000000000000000000000001559954712

In[152]:= 34600848595471336691446124576274^m - m

Out[152]= 841243.00000000000000000000000000000000146089062

In[157]:= 543136599664447978486581955093879^m - m

Out[157]= 1411134.0000000000000000000000000000000035813431

In[159]:= 748013345032523806560071259883046^m - m

Out[159]= 1498583.0000000000000000000000000000000031130944

In[162]:= 509030286753987571453322644036990^m - m

Out[162]= 1394045.9999999999999999999999999999999946679646


In[48]:= 952521560422188137227682543146686124^m - m

Out[48]=5740880.999999999999999999999999999999999890905129816474332198321490136628009367504752851478633240


In[26]:= 50355477632979244604729935214202210251^m - m

Out[26]=12097427.00000000000000000000000000000000000000293025439870097812782596113788024271834721860892874


In[27]:= 204559420776329588951078132857792732385^m - m

Out[27]=15741888.99999999999999999999999999999999999999988648448116819373537316944519114421631607853700001


In[46]:= 4074896822379126533656833098328699139141^m - m

Out[46]= 27614828.00000000000000000000000000000000000000001080626974885195966380280626150522220789167201350


In[8]:= 100148763332806310775465033613250050958363^m - m

Out[8]= 50392582.999999999999999999999999999999999999999998598093272973955371081598246


In[10]=  116388848574396158612596991763257135797979^m - m

Out[10]=51835516.000000000000000000000000000000000000000000564045501599584517036465406


In[12]:= 111821958790102917465216066365339190906247589^m - m

Out[12]= 188339125.99999999999999999999999999999999999999999999703503169989535000879619


In[33] := 8836529576862307317465438848849297054082798140^m - m

Out[33] = 42800817.00000000000000000000000000000000000000000000000321239755400298680819416095288742420653229


In[71] := 532482704820936890386684877802792716774739424328^m - m

Out[71] =924371800.999999999999999999999999999999999999999999999998143109316148796009581676875618489611792


In[21]:= 783358731736994512061663556662710815688853043638^m - m

Out[21]= 993899177.0000000000000000000000000000000000000000000000022361744841282020


In[24]:= 8175027604657819107163145989938052310049955219905^m - m

Out[24]= 1544126008.9999999999999999999999999999999999999999999999999786482891477\
944981


19779617801396329619089113017251584634275124610667^m - m
gives
1822929481.00000000000000000000000000000000000000000000000000187580971544991111083798248746369560.


130755944577487162248300532232643556078843337086375^m - m

gives 

2599324665.999999999999999999999999999999999999999999999999999689854836245815499119071864529772632.
i.e.2, 599, 324, 665. 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 689

(51 consecutive 9 s)

322841040854905412176386060015189492405068903997802^m - m

gives

3080353548.000000000000000000000000000000000000000000000000000019866002281287395703598786588650156

i.e. 3, 080, 353, 548. 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000,019

(52 consecutive 0 s)


310711937250443758724050271875240528207815041296728160^m - m

gives

11195802709.99999999999999999999999999999999999999999999999999999960263763...
i.e. 11,195,802,709. 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 602, 637,63

(55 consecutive 9s)

1465528573348167959709563453947173222018952610559967812891154^ m - m  
gives 
200799291330.9999999999999999999999999999999999999999999999999999999999999900450730197594520134278  
i. e 200, 799, 291, 330.999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 999, 99 

(62 consecutive 9 s).

Here is something that looks like it might lead to another form of arbitrarily close approximations. enter image description here

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 BY: Marvin Ray Burns

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:

enter image description here

I'll only post 1 update a week, so as not to abuse the message board.

POSTED BY: Marvin Ray Burns

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

enter image description here

. -

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.

enter image description here

. -

POSTED BY: Marvin Ray Burns

(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: enter image description here.

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:

enter image description here

...

enter image description here enter image description here

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_] := (-1`240)^(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_] := (-1`60)^(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 BY: Marvin Ray Burns

The Seventh attempt at Calculating 6,000,000 digits

Speaking of methods of computation, at Fri 11 Sep 2020 21:41:41, I started my seventh attempt at calculating 6,000,000 digits of the MRB constant with one node of the MRB constant supercomputer. Here are the MRB method program and recent output.

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

            SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**
                N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, 
                cores - 1}, Method -> "EvaluationsPerKernel" -> 32]];
        ctab = ParallelTable[Table[c = b - c;
              ll = start + l - 2;
              b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
              c, {l, chunksize}], 
      Method -> "EvaluationsPerKernel" -> 16];
        s += ctab.(xvals - 1);
        start += chunksize;
        st = SessionTime[] - T0; kc = k*chunksize;
        ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
        If[kc > 1, 

     Print["As of  ", DateString[], " there were ", kc , 
      " iterations done in ", N[st, 5], " seconds. That is ", 
      N[kc/st, 5], " iterations/s. ", N[kc/(end* chunksize)*100, 7], 
      "% complete.",
            " It should take ", N[ti, 6], " days or ", 
      N[ti*24*3600, 4], 
            "s, and finish ", DatePlus[ds, ti], "."]]; 
    Print[];, {k, 0, end - 1}];
      N[-s/d, pr]];
t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", 
  DateString[], ". Proccessor and actual time were ", 
 t2[[1]], " and ", SessionTime[] - T0, " s. respectively"];
Print["Enter MRB1 to print ", Floor[Precision[MRB1]], 
   " digits. The error from a 5,000,000 or more digit calculation \
that used a different method is  "]; N[MRB - MRB1, 20]
 As of  Sat 19 Sep 2020 09:00:54 there were 356352 iterations done in
 6.4555*10^5 seconds. That is 0.55201 iterations/s. 4.476460% complete. 
    It should take 166.890 days or 1.442*10^7s, 
 and finish Thu 25 Feb 2021, 19:03:08.

See https://www.wolframcloud.com/obj/bmmmburns/Published/MRB%202020.nb for up-to-date notebook.

Due to a battery backup that surged, the MRB constant supercomputer suffered great damage, and of course, the computation failed.

POSTED BY: Marvin Ray Burns

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

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

enter image description here

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

https://www.wolframcloud.com/download/bmmmburns/Published/MRBSC 1.nb

https://www.wolframcloud.com/download/bmmmburns/Published/MRBSC 2.nb

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

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

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

https://www.wolframcloud.com/env/bmmmburns/MRBSC2%206%20million.nb https://www.wolframcloud.com/download/bmmmburns/Published/MRBSC2 6 million.nb

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: speed records

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.

first 3 way cluster

3/23/2019

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

Added to my cluster of

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

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

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

Total: $2,695.00.

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

3 node MRB Digital Storm 2

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!

POSTED BY: Marvin Ray Burns

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 BY: Marvin Ray Burns

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

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

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

The 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 BY: Marvin Ray Burns
Posted 1 year ago

Update on the 6,000,000 digit computation.

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

Latest output:

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

POSTED BY: Updating Name

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 BY: Marvin Ray Burns

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

enter image description here

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." enter image description here

Here is a similar distribution over the first 4,000,000: enter image description here

3,000,000 digits share a similar distribution:

enter image description here

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: enter image description here

I attached more than 6,000,000 digits of the MRB constant.

Attachments:
POSTED BY: Marvin Ray Burns

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 BY: Marvin Ray Burns