Group Abstract Group Abstract

Message Boards Message Boards

Try to beat these MRB constant records!

POSTED BY:

Marvin Ray Burns, and distinguished colleagues

Beginning on January 20, 2014, this discussion has focused on researching the MRB constant, primarily using the Wolfram Toolbox.

  • March 31, 2020 (4:00 AM) – 120,000 views, averaging 2.14 views per hour since inception.
  • January 2, 2021 (4:00 AM) – 300,000 views, increasing the lifetime average to 3.56 views per hour.
  • February 3, 2021 (8:30 PM) – 330,000 views, adjusting the overall rate to 3.55 views per hour.
  • October 8, 2021 (7:00 PM) – 520,000 views, increasing the long-term average to 4.02 views per hour.
  • March 2, 2022 (1:40 AM) – 600,000 views, now averaging 4.05 views per hour over its lifetime.
  • May 4, 2022 (8:25 PM) – 650,000 views, meaning 14.96 views per hour over the last seven months.
  • January 20, 2023 – 695,000 views, achieving 8.8 views per hour, or one view every 6.8 minutes.
  • January 15, 2024 – 810,223 views, averaging 9.24 views per hour, or one view every 6.49 minutes.
  • May 14, 2024 (8:00 AM) – 1,000,000 views, reaching 11.06 views per hour.

  • From May 14, 2024 (8:00 AM) at 1,000,000 views to April 22, 2025 (7:00 AM) at 1,120,000 views, the time span is 343 days (or 8,232 hours).
    -* During this period, 120,000 new views were recorded.
    -* So, the average views per hour this past year was approximately 14.59 views per hour.

  • Also, on average, this discussion has received 11.38 views per hour since its inception

The MRB constant, a fascinating mathematical anomaly, has intrigued researchers and enthusiasts alike for decades. Defined as the limiting value of a unique alternating series, this enigmatic constant showcases the beauty of numerical exploration and convergence. Despite its relatively recent emergence, the MRB constant continues to reveal unexpected connections to various fields within mathematics and computational analysis. In this post, we dive into its origins, properties, and the ongoing quest to uncover its deeper significance The MRB constant is considered an anomaly because it emerges from an alternating series with unusual convergence behavior. Unlike many well-known mathematical constants, the MRB constant does not have a closed-form expression, and its exact nature—whether it is algebraic, transcendental, or even irrational—remains unknown. Additionally, the sequence of partial sums that define the MRB constant oscillates between two limit points, creating a bounded yet divergent behavior. This oscillatory nature makes it distinct from more conventional mathematical constants, which typically exhibit straightforward convergence. Its mysterious properties continue to intrigue mathematicians, as they explore its deeper connections to number theory and computational analysis.

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

is the MRB constant.

Forward

I've heard my fellow amateurs prematurely boast of their GREAT DISCOVERIES and seen them fall on the jagged rocks of a lack of proof, commonality with known facts or various other forms of error. And I, also, did stumble over many of them while first trying to describe the MRB constant. Trying to never do the wrong thing twice, I believe I've finally made a positive effect in the field of mathematics. On the way, one obstacle I had to negotiate was people shutting me down by saying it is a mere novelty and is therefore not worth investigating. But with further thought I came up with this objection:

Studying the MRB constant's place in mathematics can introduce one to the following:

Number Theory
The study of integers and their properties, including prime numbers. The discovery of large primes is a monumental task that involves deep number theoretic concepts and advanced computational techniques.

Behavior of Series and Sequences
Understanding how series and sequences behave, converge, or diverge is fundamental in mathematical analysis. This includes the study of oscillatory sums and their limit points, which is directly related to the investigation of the MRB constant.

Dirichlet Eta Function and Its Derivatives
The Dirichlet eta function, a variant of the Riemann zeta function, plays a crucial role in analytic number theory. Its properties and derivatives have implications for the MRB constant and other mathematical phenomena.

Limit Points and Oscillatory Sums
Investigating the limit points within oscillatory sums involves understanding how sequences and series approach their limits, which is essential in various fields of mathematics.
The MRB constant’s exploration touches on all these areas, revealing the interconnectedness of different mathematical concepts. It’s a testament to how seemingly disparate areas of mathematics can come together to uncover new insights and deepen our understanding of the mathematical universe.

So, in the spirit of Leopold Kronecker, a German mathematician and logician who famously said, what translates to "God made the integers, all the rest is the work of man":

Here are a few fundamental constants that were once considered novel discoveries:
- φ (Golden Ratio): Known to the ancient Greeks, it gained prominence in art, architecture, and mathematics over time.
- π (Pi): π has been known since ancient times, but its significance and applications were fully appreciated much later.

Euler’s Number (e)
Discovered by Jacob Bernoulli in his studies of compound interest, this number became a cornerstone in calculus and mathematical analysis. It's fundamental to growth models, logarithms, and many branches of mathematics.

Imaginary Unit (i)
Introduced by René Descartes, this constant initially faced skepticism but later became indispensable in complex analysis and engineering. It represents the square root of -1, opening doors to understanding dimensions beyond the real world.

Euler-Mascheroni Constant (γ)
Defined as the limiting difference between the harmonic series and the natural logarithm, this constant was introduced by Leonhard Euler in the 18th century. It appears in areas such as number theory and analysis, enriching the mathematical landscape.

I hope that within this discussion we will find that the MRB constant is also becoming an essential part.

Motivation for the MRB constant

Obsessed by people calculating digits of the square root of two, cube root of three and so on, I didn't want to miss out on the fun of setting some kind of computational record. So, in 1994 I began to investigate a mathematical expression, n^(1/n), which has led to many interesting results. By 1999 worried that the Y2K bug would close down computing as we knew it, I found its sum over ℕ, which other mathematicians named in my honor.

CONSTRUCTING THE MRB CONSTANT IN MATHEMATICA

Let

Click here<- for some basic constructs of the MRB constant and what is called its integrated analog. That is an integral of f(z) over the right half-plane of cos(Pi*z)(z^(1/z)-1).

Unlikely looking constructions for the MRB constant

In 2012, a rapidly convergent pair of series for CMRB (S) were discovered using Series and Functional Definition Optimization by the then Chief cryptographer of Apple computer, Dr. Crandall.

$$\begin{align*} S &= \sum_{m \ge 1} \frac{(-1)^m}{m!} \eta^{(m)}(m), \\ \\ S &= \sum_{m \ge 1} \frac{c_m}{m!} \eta^{(m)}(0), \\ \\ \text{where the $c$ coefficients are defined}\\\ c_j &:= \sum_{d=1}^{j} \binom{j}{d} (-1)^d d^{j-d}. \end{align*}$$

Since Crandal died before publishing his proof, I tried to prove it and eventually asked my readers for help. Finally, Gottfried Helms proved one publicly:

Gottfried Helms

Note: because of this, the MRB constant sum prototype, can be split into an asymptotic component and a remainder, and these components together reconstruct the original series, converging to the MRB constant

MRB constant Conditional Convergence

nb1

According to the Wolfram Notebook Assistant, the Riemann Series Theorem says:

By a suitable rearrangement of terms, a conditionally convergent series may be made to converge to any desired value, or to diverge.

According to the Wolfram Notebook Assistant, this may be done by:

(1.) Rearrange Positive and Negative Terms:

  • Separate the series into positive terms an+ and negative terms an

  • Both $\Sigma$an+ and $\Sigma$an- diverge because the series is conditionally convergent.

(2.) Target Sum:
Let S be the target sum you want the rearranged series to converge to.

(3.) Construct the Rearrangement:

  • Start summing positive terms until the partial sum exceeds S.
  • Add negative terms until the sum falls below S.
  • Repeat this process, adding positive terms to exceed S, then negative terms to fall below S.

(4.) Convergence to S:

  • This process constructs a new series that converges to S.
  • Since both positive and negative sums diverge and can be made arbitrarily large, the partial sums can be made to oscillate around S and eventually converge to it.

Generalization:

By choosing different strategies for rearranging the terms, you can make the series converge to any real number or diverge. This theorem shows the delicate nature of convergence in conditionally convergent series and the non-uniqueness of their sum under rearrangement.

For example,

$$ S = 1 - \frac{1}{2} + \frac{1}{3} - \frac{1}{4} + \cdots $$

converges to $\ln 2$, but the same series can be rearranged to

$$ 1 - \frac{1}{2} + \frac{1}{4} - \frac{1}{3} + \frac{1}{6} + \frac{1}{5} + \frac{1}{8} - \cdots $$

so the series now converges to half of itself.

The wonderful point of theorems is that they are true without exceptions. Hence, the MRB constant series of irrational terms must also equal any rational, as well as any transcendental number of our choosing! Despite an infinitude of them being irrational, as well as algebraic.

->Here<- is a rearrangement of terms of the MRB constant series that add up to within 6.48303*10^-7 of the value of pi.

MRB constant Absolute Convergence

an Analog to the Exponential Function

Leading to an Integral Representation

Below, analog-type- positioning of the MRB-constant and e-to-the x formulas stem from an absolutely convergent series.

Mathematica confirms it here:

In[405]:= test = (2 k)^(1/(2 k)) - (2 k + 1)^(1/(2 k + 1));

In[406]:= SumConvergence[Abs[test], k]

Out[406]= True

In mathematical analysis, series expansions provide powerful tools for approximating functions and exploring their properties. A classic example is the Taylor series expansion of the exponential function $$e^x$$, which elegantly divides into sequences of even and odd powers. These sequences reveal deeper connections to the hyperbolic sine and cosine functions, where even powers correspond to the series expansion of $$\cosh(x)$$ and odd powers to that of $$\sinh(x)$$. This separation showcases the inherent symmetry and structure within the exponential function.

Similarly, the exploration of the MRB constant reveals intriguing parallels. The MRB constant is defined through an alternating series involving the expression $$n^{1/n}$$. Just as with the exponential function, one can examine the series by segregating terms based on parity: odd versus even terms. This division, while not directly yielding trigonometric or hyperbolic functions, highlights a structural analogy that invites deeper investigation into the convergence and behavior of such series.

Both the decomposition of the exponential function and the partitioning of the MRB constant series into odd and even components underscore the rich interplay between algebraic expressions and their geometric or analytic interpretations. Understanding these connections enriches our comprehension of mathematical constants and functions, providing insights that extend beyond the immediate formulations.

When studying calculi of approximations as we do in this discussion, spectral analysis, or quantum field theories, replacing discrete sums, like the above MRB constant, with an integral involving hyperbolic functions can reveal deeper properties in such as

$$ \sum_{n=1}^{\infty} \left( \sqrt[2n]{2n} - \sqrt[2n-1]{2n-1} \right) == C_{MRB} = \int_{0}^{\infty} \frac{\mathfrak{F} \sqrt[1+t]{1+ i t}}{\sinh(\pi t)} dt .$$

The similarity in exponential decay or growth between discrete and continuous representations may explains the why of this equation.

Using a variation of the Abel–Plana formula:

$$\sum_{n=0}^\infty (-1)^nf(n)= \frac {1}{2} f(0)+i \int_0^\infty \frac{f(i t)-f(-i t)}{2\sinh(\pi t)} \, dt, $$

a follower going by the moniker Dark Malthorp presented a beautiful integral for the MRB constant, where for

\begin{equation*} f(x) = 1 - (1 + i x)^{\frac{1}{1 + i x}} \end{equation*}

$$C_{MRB}$$

$$== \sum_{0}^{\infty} \frac{\Re (f(t))}{\sinh(i \pi t)+\cosh(i \pi t)}$$ $$== \int_{0}^{\infty} \frac{\Im (f(t))}{\sinh(\pi t)} dt$$

To apply Abel-Plana, bounds on $f(z)$ are needed. Although not holomorphic on $\Re(z)$ at $0$, it is still manageable since $\lim_{x \rightarrow \infty} f(x + yi) = 0$ for all fixed $y$, and it is bounded in the right half-plane. Using the alternating series formulation of Abel-Plana:

$$C_{MRB} = \sum_{n=0}^{\infty} (-1)^n f(n) = \frac{1}{2} f(0) + i \int_{0}^{\infty} \frac{f(it) - f(-it)}{2 \sinh(\pi t)} dt$$

relate the imaginary part terms to the MRB series\

Simplifying the integral:

\begin{align*} &= \frac{1}{2} \cdot 0 + i \int_{0}^{\infty} \frac{1 - (1 + it)^{\frac{1}{1 + it}} - 1 + (1 - it)^{\frac{1}{1 - it}}}{2 \sinh(\pi t)} dt \ &= i \int_{0}^{\infty} \frac{-(1 + it)^{\frac{1}{1 + it}} + (1 - it)^{\frac{1}{1 - it}}}{2 \sinh(\pi t)} dt \end{align*}

Holomorphic Property

Since $(1 + \frac{1}{x})$ is holomorphic for $\Re(z) \geq 0$ and real-valued for real $z$, it follows that $f(z) = \overline{f(z)}$. This leads to:

$$C_{MRB} = \int_{0}^{\infty} \frac{\Im (f(t))}{\sinh(\pi t)} dt $$

Although we cannot strictly pull the imaginary part out of the integral due to the pole at 0, the imaginary part remains bounded for $t \in (0, \infty)$. I don't see why we cannot write enter image description here N[Integrate[ Im[(1 + It)^(1/(1 + It))]/Sinh[Pit], {t, 0, Infinity}] == 2Integrate[ Im[E^(Pit + Log[1 + It]/(1 + It))]/(E^(PiI) + E^(2Pit)), {t, 0, Infinity}]]

Also, we can take the imaginary part of the outside in the following.

enter image description here

N[Integrate[
   Im[(1 + I*t)^(1/(1 + I*t))]/Sinh[Pi*t], {t, 0, Infinity}]] - 
   N[Im[Integrate[
    Integrate[
     Im[E^(Log[t]/t + x)/(E^(x + I*Pi*t) - E^(x - I*Pi*t))], {x, -t, 
      t}], {t, 1, I*Infinity}]]]

Regressing to the flow of "MRB constant Absolute Convergence an Analog to the Exponential Function Leading to an Integral Representation," The connection between the MRB constant and the integral expression involving complex functions arises from advanced mathematical analysis and the exploration of series convergence properties through complex analysis techniques.

High level proof of

$$C_{MRB} = \int_{0}^{\infty} \frac{\Im (f(t))}{\sinh(\pi t)} dt $$

without the Abel-Plana theorem

by the Wolfram Notebook Assistant

Certainly! Here's a condensed version of your proof, maintaining all the critical computations and steps:

Proving the Connection between the MRB Constant and its Integral Representation

This proof involves complex analysis, asymptotic analysis, and special functions to establish the relationship between the MRB constant and its integral form.

1. Series Representation

Define the MRB constant as an alternating series: $$\text{MRB} = \sum_{n=1}^{\infty} (-1)^n (n^{1/n} - 1)$$

2. Complex Function Representation

Consider the complex function: $$(1 + it)^{1/(1 + it)}$$ This function captures the essence of the series term $$n^{1/n}$$ and can be expanded to show its behavior in the complex plane.

3. Integral Representation

The integral: $$\text{CMRB} = \int_0^\infty \text{Im}\left[(1 + it)^{1/(1 + it)} \text{Csch}(\pi t)\right] \, dt$$ connects the series with the integral using complex analysis techniques.

4. Asymptotic Analysis and Convergence

Analyze the asymptotic behavior of $$(1 + it)^{1/(1 + it)}$$ and $$\text{Csch}(\pi t)$$ to ensure the integral converges, examining $$t \to 0$$ and $$t \to \infty$$.

5. Relate Series Terms to Integral Components

Expand the complex function $$f(t) = (1 + it)^{1/(1 + it)}$$ as: $$f(t) \approx 1 + a_1 t + a_2 t^2 + \cdots$$ Extract the imaginary part: $$\text{Im}[f(t)] \approx b_1 t + b_3 t^3 + \cdots$$ Relate these terms to the MRB series, highlighting the alternating nature with $$(-1)^n n^{1/n}$$.

6. Use Analytic Continuation

If necessary, utilize analytic continuation to explore the series and integral in a unified framework.

7. Convergence Analysis

At Infinity: Analyze $$\text{Im}[f(t)] \text{Csch}(\pi t)$$ to confirm convergence with damping by $$\text{Csch}(\pi t)$$. Near Zero: Assess behavior around $$t = 0$$ using the series expansion.

8. Numerical Verification

Perform numerical computations for both the MRB series and the integral, ensuring they converge to the same value. Truncate and compare finite sums to verify consistency.

**Here is a program I wrote that ensures they converge to the same value, as well as, perhaps asymptotically by the expression (2sin(1))/(tsinh([Pi] t)) , where t is the precision. **

Conclusion

By expanding the complex function, analyzing convergence, and verifying numerically, we establish a robust connection between the MRB constant and its integral representation. This approach not only proves the equivalence but also deepens our understanding of the underlying mathematical structures.

This condensed proof outlines the critical steps and computations needed to establish the connection, focusing on the interplay between series terms and their integral counterparts. While the proof requires a deep understanding of complex analysis and asymptotic methods, the crux lies in showing that the complex integral captures the oscillatory and convergence behavior of the MRB series through a carefully constructed analytic expression. This approach not only proves the connection but also enriches our understanding of the MRB constant's mathematical nature.

A lower-level proof follows from the proceeding sum-integral identity.

Yet another MRB constant integral

On Pi Day, 2021, 2:40 pm EST,

I added a new MRB constant integral. Surprisingly to me, this one is proven by the mere definition of the Residue Theorem: With additional thought, the previous sum-integral and this integral-sum can be seen as the same identity or relation by a factor of i, so this new proof solidifies our high-level one. The Wolfram Assistant proved it.

CMRB = integral to sum

Proof: enter image description here

The notebook assitant clarified:

The appearance of the cosine function in the series is due to how the real part of the integral and the series terms are related, rather than a direct transformation of Csc into Cos. The real part of the expression and the periodicity of cosine (due to the integer poles considered) naturally lead to the involvement of cosine in the final expression.

enter image description here

Conclusion This proof shows how the original integral can be transformed into an infinite series by leveraging complex analysis techniques, specifically contour integration and the residue theorem. Each step builds on the analytical properties of the function and the behavior of its poles in the complex plane.

If the header and the words

Reply | Flag

are shown at the same time in any of the following replies, refresh the page to see them.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)
20 Replies
Sort By:

Examples of further research unveiling the utility of the MRB constant

The MRB constant early interest

As early as 1999, after I emailed him, technical writer at MathSoft Inc. Dr. Steven Finch shared the following query about the MRB constant;

Marvin Ray Burns asked about $$ \lim_{N \to \infty} \sum_{n=1}^{2N} (-1)^n n^{\frac{1}{n}} = \sum_{k=1}^{\infty} \left( (2k)^{\frac{1}{2k}} - (2k-1)^{\frac{1}{2k-1}} \right) $$

which is slowly convergent (on the order of only $\ln(k)/k^2 $). No exact formula for this series is known, although it bears some resemblance to expressions mentioned with the Glaisher-Kinkelin constant and with infinite product constants. It may also be rewritten as

$$ =\sum_{m=1}^{\infty} (-1)^m \left( m^{\frac{1}{m}} - 1 \right) = 1 + \lim_{N \to \infty} \sum_{n=1}^{2N+1} (-1)^n n^{\frac{1}{n}} = 0.1878596424\ldots $$

Using Cohen-Villegas-Zagier's acceleration technique of convergent alternating series, Burns obtained a high-precision estimate of this constant. I am not certain if required hypotheses are met. Can someone help here?

Before his MIT Sloan School of Management's current role as Research Computing Specialist, in 2003 Statistical Computing Scientist/Preceptor at the Harvard University Department of Statistics, Professor Steven Finch was the first to publish about the MRB constant in book form under the auspices of Cambridge Press:

A more difficult evaluation concerns the series

$$ \lim_{N \to \infty} \sum_{n=1}^{2N} (-1)^n n^{\frac{1}{n}} = \sum_{k=1}^{\infty} \left( (2k)^{\frac{1}{2k}} - (2k-1)^{\frac{1}{2k-1}} \right) $$

$$ =\sum_{m=1}^{\infty} (-1)^m \left( m^{\frac{1}{m}} - 1 \right) = 1 + \lim_{N \to \infty} \sum_{n=1}^{2N+1} (-1)^n n^{\frac{1}{n}} = 0.1878596424\ldots $$

which is slowly convergent. No exact formulas are known, although the series bear some resemblance to expressions mentioned in [2.15]. Cesàro summation and Cohen-Villegas-Zagier acceleration are two techniques available to compute the sum.

The MRB constant integrated analog

On February 22 2009, I asked:

it appears that the absolute value, minus 1/2, of the integral of (-1)^x*x^(1/x) from 1 to 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?

As found here, whether in response or for other reasons,

Richard J. Mathar of CERN published the foundational work of its integrated analog.

INTEGRAL OVER exp(ix)x^{1/x} BETWEEN 1 AND INFINITY arXiv:0912.3844v3 [math.CA] 5 Aug 2010

NUMERICAL EVALUATION OF THE OSCILLATORY INTEGRAL OVER $\exp(i \pi x)x^{1/x}$ BETWEEN 1 AND INFINITY

RICHARD J. MATHAR

Real and imaginary part of the limit $2N \to \infty$ of the integral

$$ \int_{1}^{2N} \exp(i\pi x) x^{1/x} dx $$

are evaluated to 20 digits with brute force methods after multiple partial integration, or combining a standard Simpson integration over the first half wave with series acceleration techniques for the alternating series co-phased to each of its points. The integrand is of the logarithmic kind; its branch cut limits the performance of integration techniques that rely on smooth higher order derivatives.

First, following-up on my inquiries about the efficient computation of the MRB constant digits mentioned in the above paper, Henrik Schachner, --from the Radiation Therapy Center in Weilheim, Germany, who is a physicist with a PhD from the University of Regensburg and currently working in medical physics, now in radiotherapy, previously in radiology had the most instructive remark.

here:

enter image description here

ClearAll["Global`*"]
m = Table[N[(-1)^k (k^(1/k) - 1), 2000], {k, 1, 2000}];
(*partial sums of the series*)
am = Accumulate@m;
shanks[ac_List] := 
 Table[(ac[[n + 1]] ac[[n - 1]] - ac[[n]]^2)/(ac[[n + 1]] + 
     ac[[n - 1]] - 2 ac[[n]]), {n, 2, Length[ac] - 1}]
sac = NestList[shanks, am, 24];
ListLogPlot[Abs[Differences /@ sac], Joined -> True, 
 GridLines -> Automatic, ImageSize -> Large]

enter image description here

This plot showcases the Shanks transformation that can be applied iteratively, leading to further improvements in MRB constant calculations.

Studying Mathar R. J. has led to many programs and formulas to compute the integrated analog of the MRB constant.

The efficient programs

Wed 29 Jul 2015 11:40:10

From an initial accuracy of only 7 digits,

0.07077603931152880353952802183028200137`19.163032309866352 - 
 0.68400038943793212918274445999266112671`20.1482024033675 I - \
(NIntegrate[(-1)^t (t^(1/t) - 1), {t, 1, Infinity}, 
    WorkingPrecision -> 20] - 2 I/Pi)

(5.256245460165610^-7 - 5.0557218633576410^-6 I)

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

Block[{$MaxExtraPrecision = 200}, prec = 4000; f[x_] = x^(1/x);
 ClearAll[a, b, h];
 Print[DateString[]];
 Print[T0 = SessionTime[]];

 If[prec > 35000, d = Ceiling[0.002 prec], 
  d = Ceiling[0.264086 + 0.00143657 prec]];

 h[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];

 h[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];

 sinplus1 := 
  NIntegrate[
   Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];

 cosplus1 := 
  NIntegrate[
   Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];

 middle := Print[SessionTime[] - T0, " seconds"];

 end := Module[{}, Print[SessionTime[] - T0, " seconds"];
   Print[c = Abs[a + b]]; Print[DateString[]]];


 If[Mod[d, 4] == 0, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
  end];


 If[Mod[d, 4] == 1, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];

 If[Mod[d, 4] == 2, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
  end];

 If[Mod[d, 4] == 3, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
  end];]

May 2018

I got substantial improvement in calculating the digits of MKB by using V11.3 in May 2018, my new computer (processor Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz, 3601 MHz, 4 Core(s), 8 Logical Processor(s) with 16 GB 2400 MH DDR4 RAM):

Digits  Seconds
2000    67.5503022
3000    217.096312
4000    514.48334
5000    1005.936397
10000   8327.18526
 20000  71000

They are found in the attached 2018 quad MKB.nb.

They are twice as fast,(or more) as my old records with the same program using Mathematica 10.2 in July 2015 on my old big computer (a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of 1066 MHz DDR3 RAM):

digits          seconds

2000    256.3853590 
3000    794.4361122
4000       1633.5822870
5000        2858.9390025
10000      17678.7446323 
20000      121431.1895170
40000       I got error msg

May 2021

After finding the following rapidly converging integral for MKB, enter image description here I finally computed 200,000 digits of MKB (0.070776 - 0.684 I...) Started ‎Saturday, ‎May ‎15, ‎2021, ‏‎10: 54: 17 AM, and finished at 9:23:50 am EDT | Friday, August 20, 2021, for a total of 8.37539*10^6 seconds or 96 days 22 hours 29 minutes 50 seconds.

The full computation, verification to 100,000 digits, and hyperlinks to various digits are found below at 200k MKB A.nb. The code was 

g[x_] = x^(1/x); u := (t/(1 - t)); Timing[
 MKB1 = (-I Quiet[
      NIntegrate[(g[(1 + u I)])/(Exp[Pi u] (1 - t)^2), {t, 0, 1}, 
       WorkingPrecision -> 200000, Method -> "DoubleExponential", 
       MaxRecursion -> 17]] - I/Pi)]

The Wolfram Notebook assistant proved this.

To construct a detailed proof that demonstrates the equality of the two integrals using series expansions, contour integration, and numerical verification, we can proceed with the following steps: Step1 Step2 Step3 Conclusion Theoretical analysis using series expansions and contour integration, combined with numerical verification, demonstrates the equality of the two integrals. The contour integral approach ensures that the integrals along the real and imaginary axes are equivalent, up to the added term. This illustrates the equivalency of these two complex integrals.

After finding the above more rapidly converging integral for MKB, In only 80.5 days, 189,330 real digits and 166,700 imaginaries were confirmed to be correct by the following different formula. as Seen at https://www.wolframcloud.com/obj/bmmmburns/Published/2nd%20200k%20MRB.nb

All digits at

https://www.wolframcloud.com/obj/bmmmburns/Published/200K%20confirmed%20MKB.nb (Recommended to open in desktop Mathematica.)

N[(Timing[
   FM2200K - (NIntegrate[(Exp[Log[t]/t - Pi t/I]), {t, 1, Infinity I},
        WorkingPrecision -> 200000, Method -> "Trapezoidal", 
       MaxRecursion -> 17] - I/Pi)]), 20]

I've learned more about what MaxRecusion is required for 250,000 digits to be verified from the two different formulas, and they are being computed as I write. It will probably take over 100 days. Let's try to formalize this derivation.

  • The MRB constant eta derivations

The continuing development of MRB constant formulas connect the Dirichlet eta to nth roots yielding a proof of the previously proposed concept that the MRB constant connects such ideas together.

Published in his life-time collection, Algorithmic Reflections: Selected Works, professor Richard Crandall of Reed College made the case that the MRB constant is indeed a key fundamental constant

Achieved here

To summarize his thesis.

The MRB constant's eta formula connects various zeta function variants through its use of series and its relationship to other special functions. Let's explore this connection in detail.

The MRB Constant and Its Series Representation The MRB constant (B as he put it) is defined by a specific series involving alternating sums:

enter image description here

This series converges quickly, making it efficient for high-precision calculations. Here's how this ties together various zeta function variants:

Relationship to Zeta Function Variants Eta Function: The eta function η(s) is a variant of the Riemann zeta function ζ(s) and is defined as: $ \eta(s) = (1 - 2^{1-s}) \zeta(s)$

1 2

shown here,

enter image description here

This has led to faster convergence of digits, so in search for a suitable approximation to the MRB constant to answer several questions about patterns in its decimal approximation,

millions1

millions2

From ScienceDirect:

Science Direct summary

All the formulas for the MRB constant and its integrated analog are in Results from further research unveiling the utility of the MRB constant
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

Wolfram Research

Spigot Algorithms

I'd be amiss if I didn't mention the efficient work Wolfram Research put into the MRB constant. Because of their effort, using only five short lines, you can find any nth digit, up to around n=six point five million of the MRB constant in an instant. I wonder if it's possible to make such a program to extract further along digits.

\
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

PARTIAL SUM METHODS FOR MRB CONSTANT

The success in computing millions of digits of the MRB constant, found in a following reply, lies in the use of Crandall's method (though hidden), his and my very fast algorithms for n^(1/n) and a modern series acceleration.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

From a drawn-out conversation with the Wolfram Notebook Assistant, I believe a suspicion I've had for a long time is true: While the MRB constant is primarily a mathematical curiosity, it can be used as a metaphorical or analytical tool to describe and understand the cumulative effects of alternating growth patterns in systems like financial markets, where regular cycles of expansion and contraction are observed.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

While preparing for the verifying of 7-million digits, I broke some speed records with two of my i9-14900K 6400MHZRAM (overclocked CPUs), using Mathematica 11.3 and the lightweight grid. They are generally faster than the 3 node MRB constant supercomputer with remote kernels! Unless noted by the command Timing[], i.;e., the last yellow and the final two blue-highlighted columns in the fourth table, these are all absolute timings. How does your computer compare to these? What can you do with other software?

1 2 3 4

That light blue highlight, red text columns, which shows processor times result here->7200 corrected timing for 30k and was tweaked in 2025.

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

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

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

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

and linked "speed records 5 10 20 30 K"

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

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

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

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

As for single-device records are concerned, the fourth table: enter image description here The yellow-highlighted column is documented here<- (with the others already documented above). enter image description here

This is another comparison of my fastest computers' timings in calculating digits of CMRB: enter image description here

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

The i9-12900KS column is documented here.

The i9-13900KS column is documented here.

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

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

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

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

Remembering that the integrated analog of the MRB constant is M2

NIntegrate[(-1)^n (n^(1/n) - 1), {n, 1, Infinity  I}, 
 Method -> "Trapezoidal", WorkingPrecision -> 20]

These results are from the Timing[] command: M2

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

The i9-12900KS column is documented here.

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

Attachments:
3 fastest comput...nb
kernel priority ...nb
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

§13.

MRB Constant Records,

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

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

My inspiration to compute a lot of digits of CMRB came from this archived linked website by Simon Plouffe.

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

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

And why compute 65 digits of the MRB constant? Because having that much precision is the only way to solve such a problem as

1465528573348167959709563453947173222018952610559967812891154^ m-m, where m is the MRB constant, which gives the near integer "to beat all," 200799291330.9999999999999999999999999999999999999999999999999999999999999900450...

And why compute millions of digits of it? uhhhhhhhhhh.... "Because it's there!" (...Yeah, thanks George Mallory!) And why?? (c'est ma raison d'être!!!)

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

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

1 digit of the

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

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

enter image description here

enter image description here

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

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

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

enter image description here Sigma still can be found here.

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

enter image description here PII

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

documentation here

And here 

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

 6,995 accurate digits of CMRB were computed on June 10-11, 2003, over a period, of 10 hours, on a 450 MHz P3 with an available 512 MB RAM,

PIII

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

documentation here

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

Out[3]= 21377.7

8000 digits of CMRB completed, using a Sony Vaio P4 2.66 GHz laptop computer with 960 MB of available RAM, at 2:04 PM 3/25/2004,

enter image description here

  11,000 digits of CMRB> on March 01, 2006, with a 3 GHz PD with 2 GB RAM available calculated.

 40 000 digits of CMRB in 33 hours and 26 min via my program written in Mathematica 5.2 on Nov 24, 2006. The computation was run on a 32-bit Windows 3 GHz PD desktop computer using 3.25 GB of Ram.
The program was

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

 60,000 digits of CMRB on July 29, 2007, at 11:57 PM EST in 50.51 hours on a 2.6 GHz AMD Athlon with 64-bit Windows XP. The max memory used was 4.0 GB of RAM.

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

It looked similar to this stock image: enter image description here

100,000 digits of CMRB on Aug 12, 2007, at 8:00 PM EST, were computed in 170 hours on a 2.66 GHz Core 2 Duo using 64-bit Windows XP. The max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.
To beat that, on the 4th of July 2022, the same digits in 1/4 of an hour using the MRB constant supercomputer.
To beat that, on the 7th of July 2022, the same digits in 1/5 of an hour. 
To beat that, on the 4th of April 2024, the same digits in 1/6 of an hour. using a pair of i9-14900Ks in parallel (100,000% as fast as the first 100,000 run by a GHz Core 2 Duo!)

see one sixth hour hundred k.

 150,000 digits of CMRB on Sep 23, 2007, at 11:00 AM EST. Computed in 330 hours on a 2.66 GHz Core 2 Duo using 64-bit Windows XP. The max memory used was 22 GB of RAM. The typical daily record of memory used was 17 GB of RAM.

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

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

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

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

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

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

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

  299,998 Digits of CMRB: The computation began Fri 13 Aug 2010 10:16:20 pm EDT and ended 2.23199*10^6 seconds later |  Wednesday, September 8, 2010. using Mathematica 6.0 for Microsoft Windows (64-bit) (June 19, 2007), which averages 7.44 seconds per digit.using a Dell Studio XPS 8100 i7 860 @ 2.80 GHz with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929 GB of virtual Ram.

enter image description here

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

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

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

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

1,048,576 digits of CMRB in a lightning-fast 76.4 hours, finishing on Dec 11, 2012, were scored by Dr. Richard Crandall, an Apple scientist and head of its advanced computational group. That was on a 2.93 GHz 8-core Nehalem,  1066 MHz, PC3-8500 DDR3 ECC RAM.

    To beat that, in Aug of 2018, 1,004,993 digits in 53.5 hours 34 hours computation time (from the timing command) with 10 DDR4 RAM (of up to 3000 MHz) supported processor cores overclocked up to 4.7 GHz! Search this post for "53.5" for documentation. 

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

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

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

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



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

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

see also 30 hour million

36.7 hours million notebook

31.2319 hours million

 A little over 1,200,000 digits, previously, of CMRB in 11   days, 21 hours, 17 minutes, and 41 seconds (I finished on March 31, 2013, using a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz. see https://www.wolframcloud.com/obj/bmmmburns/Published/36%20hour%20million.nb

for details.

2,000,000 or more digit computation of CMRB on May 17, 2013, using only around 10GB of RAM. It took 37 days 5 hours, 6 minutes 47.1870579 seconds. using a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz.

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

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

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


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

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

 Gives

  {25.5469,0.*10^-9999984}

  {101.359,0.*10^-9999984}




  More information is available upon request.

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

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

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

enter image description here

5,609,880, verified by two distinct algorithms for x^(1/x), digits of CMRB on Thu 4 Mar 2021 at 08:03:45. The 5,500,000+ digit computation using a totally different method showed that many decimals are in common with the 6,000,000+ digit computation in 160.805 days.

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

Successful code was:

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

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

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

enter image description here

The MRB constant supercomputer replied,

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

"Computation time" 72.526 days.

 "Absolute time" 185.491 days.

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

It was instantly checked to 6,029,992 or so, digits by the program itself. A 7-million-digit run using different number of digits of Exp[Log[ll]/ll] computed by each method, is in process, which will verify the residue of digits.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

Distribution of MRB constant digits as given in all record calculations

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.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)
Attachments:
2nd 6p5 million.nb
6p5millionMRB.nb
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

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 A.G.S. (cum laude)

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
Attachments:
2nd 100 k eta 4 ...nb
50 k eta 4 22 2019.nb
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

nice system!
POSTED BY: l van Veen

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

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 A.G.S. (cum laude)

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

Crandall is not using his eta formulas directly!!!!!!! He computes Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}] directly!

Going back to Crandall's code:

(*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 500000;(*Number of \
required decimals.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, 
    tsize = 2^7, chunksize, start = 1, ll, ctab, 
    pr = Floor[1.02 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["end ", end];
   Print[end*chunksize];
   d = N[(3 + Sqrt[8])^n, pr + 10];
   d = Round[1/2 (d + 1/d)];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],
        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 1]];
    ctab = Table[c = b - c;
      ll = start + l - 2;
      b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
      c, {l, chunksize}];
    s += ctab.(xvals - 1);
    start += chunksize;
    Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,
      end - 1}];
   N[-s/d, pr]];

t2 = Timing[MRBtest2 = expM[prec];];
MRBtest2 - MRBtest3

x = N[E^(Log[ll]/(ll)), iprec]; Gives k^(1/k) to only Ceiling[pr/27]; decimal places; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0 for the first 27 desired decimals.) On the other hand,

While[pc < pr, pc = Min[3 pc, pr];
 x = SetPrecision[x, pc];
 y = x^ll - ll;
 x = x (1 - 2 y/((ll + 1) y + 2 ll ll));],

takes the short precision x and gives it the necessary precision and accuracy for k^(1/k) (k Is ll there.) It actually computes k^(1/k). Then he remarks, "(N[Exp[Log[ll]/ll], pr])."

After finding a fast way to compute k^(1/k) to necessary precision he uses Cohen's algorithm 1 (See a screenshot in a previous post.) to accelerate convergence of Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}]. That is his secret!!

As I mentioned in a previous post the "MRBtest2 - MRBtest3" is for checking with a known-to-be accurate approximation to the MRB constant, MRBtest3

I'm just excited that I figured it out! as you can tell.
POSTED BY: Marvin Ray Burns A.G.S. (cum laude)

Nice work. Worth a bit of excitement, I' d say.
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 A.G.S. (cum laude)

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

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

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
Reply to this discussion
Community posts can be styled and formatted using the Markdown syntax.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Reply Preview
Attachments
Remove
or Discard