Message Boards Message Boards

Try to beat these MRB constant records!

POSTED BY: Marvin Ray Burns
39 Replies
POSTED BY: Marvin Ray Burns

If this reply is the first one displayed, refresh the page to see the main post above.

I forgot about the following trigonometric MRB constant sums and integrals:

POSTED BY: Marvin Ray Burns

Compare the results of these two sets of code. The first one is based on the MRB constant (0.18785...), and the second one, 1/e (0.367879...). Can you change these 3 trig formulas so that 1/e (or any other constant) gives the same appearance as the MRB constant does? Or are these graphs from these 3 families of trig formulas unique to the MRB constant?

m = 0.1878596424620671202485179340542732300559030949001387861720046840\
89477231564660213703296654433107496903
ListPlot[Table[Sin[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[Cos[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[
  Tan[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}], 
 Joined -> True]

enter image description hereenter image description hereenter image description here

d = 1/E
ListPlot[Table[Sin[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[Cos[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[
  Tan[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}], 
 Joined -> True]

enter image description hereenter image description hereenter image description here

P.S. It doesn't take much to simply get "geometric" shapes out of this family of trig formulas. Try the following code:

d = 1/E - 10^-2
ListPlot[Table[Sin[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[Cos[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[
  Tan[Pi/d*(5060936308 + 78389363/24*n)], {n, -100, 100}], 
 Joined -> True]

enter image description here

Plus, it don't take much error in the MRB constant's approximate value to really disfigure it's graphs. Try this code where you only use 12 digits of precision :for the MRB constant

m = 0.187859642462
ListPlot[Table[Sin[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[Cos[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}]]
ListPlot[Table[
  Tan[Pi/m*(5060936308 + 78389363/24*n)], {n, -100, 100}], 
 Joined -> True]

enter image description here

POSTED BY: Marvin Ray Burns

POSTED BY: Marvin Ray Burns

"I compare 300 years of summation methods for the MRB constant."

In the first post I mentioned summing the MRB constant by Euler's method and Crandall's method. Here I compare them:

Here are faster methods where m is the known value of the MRB constant found in the above replies:

POSTED BY: Marvin Ray Burns

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

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

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

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

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

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

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

-r

My method to first calculate 7-million digits:

It got stuck there! I suppose I overworked my computers by the large bite of chunksize*tsize which gave a 28 GB matrix! So, I square-rooted the amount of work done at one time with the following correction in yellow highlight.

(There!) it went past that sticking point. I will post any changes for you!

My code to prove that the digits are all correct:

Print["Start time is ", ds = DateString[], "."];
prec = 7000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{x11, z, t, a, d, s, k, bb, c, end, iprec, xvals, x, pc, 
    cores = 32(*=4*number of physical cores*), tsize = 128, chunksize,
     start = 1, ll, ctab, pr = Floor[1.005 pre]}, 
   chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = 20;
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[4 pc, pr];
         x = SetPrecision[x, pc];
         xll = Power[x, ll]; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x *= (1 + 
            SetPrecision[4.5, pc] (ll - 1)/t2 + (ll + 1) z/(2 ll t) - 
            SetPrecision[13.5, pc] ll (ll - 1)/(3 ll t2 + t^3 z))];(**
        N[Exp[Log[ll]/ll],pr]**)
        x - N[Log[ll], prec]/ll, {l, 0, tsize - 1}], {j, 0, 
        cores - 1}, Method -> "FinestGrained"]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], Method -> "Automatic"];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize;
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    If[kc > 1, 
     Print["As of  ", DateString[], " there were ", kc, 
      " iterations done in ", N[st, 5], " seconds. That is ", 
      N[kc/st, 5], " iterations/s. ", N[kc/(end*chunksize)*100, 7], 
      "% complete.", " It should take ", N[ti, 6], " days or ", 
      N[ti*24*3600, 4], "s, and finish ", DatePlus[ds, ti], "."]];
    Print[];, {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBeta2toinf = expM[prec];]; MRBeta1 = 
 EulerGamma Log[2] - 1/2 Log[2]^2;

Print["Finished on ", DateString[], 
  ". Proccessor and actual time were ", t2[[1]], " and ", 
  SessionTime[] - T0, " s. respectively"];
Print["Enter MRB1 to print ", 
 Floor[Precision[
   MRB1]], " digits. The error from a 6,500,000 or more digit 
    calculation that used a different method is  "]; N[
 MRBeta2toinf + MRBeta1 - m6p5M, 10]
POSTED BY: Marvin Ray Burns

While verifying 7-million digits, I broke some speed records with two of my i9-14900K 6400MHZRAM (overclocked CPUs), using Mathematica 11.3 and the lightweight grid. They are generally faster than the 3 node MRB constant supercomputer with remote kernels! These are all absolute timings! How does your computer compare to these? What can you do with other software? Table of Records left Table of Records right For column "=F" (highlighted in green) see linked "10203050100" . At the bottom, see attached "kernel priority 2 computers.nb" for column =B, "3 fastest computers together.nb" for column =C and linked "speed records 5 10 20 30 K" also speed 50K speed 100k, speed 300k and 30p0683 hour million.nb for column =D for some documentation. For the mostly red column including the single, record, 10,114 second 300,000 digit run " =E" is in the linked "3 fastest computers together 2.nb.} For the partial column of two 6000MHz 14900K' with red text and yellow highlight, see speed 100 300 1M XMP tweaked.

"

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


These 2023 records still stand:

Remembering that the integrated analog of the MRB constant is M2 is

These results are from the Timing[] command:

M2 table

The i9-12900KS column is documented here.

The 2024 i9-14900K documentation here

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

While the i-13900K worked on the 40,000 digits of M2, the processor's speed was close to 6GHz: CPU As mentioned somewhere above, the RAM speed is 4800MHz: RAM

POSTED BY: Marvin Ray Burns

7,000,000 digits on hold

With my two souped-up I9-14900 K's

it would take 90 days and $500.00 of electricity to compute, and at least 120 days and $1000.00 to check. 

I'm getting a I9-14900KS to add to my cluster and will see how it speeds the process up. It also should be very good at breaking speed records!

POSTED BY: Marvin Ray Burns

If above this you see the title "Try to beat these MRB constant records!" in order to see the first 9 sections, the basic theory of the MRB constant (CMRB), you'll need to refresh the page.

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

This is just an observation about the MRB constant sum enter image description here If the following Mathematica computations are correct, you get near rational results, by a factor of log10, when starting the sum from large integer powers of 10.

It looks like for p(x)= approximation (in blue) of x, limit as x-> infinity of p(x)/p(x+1) is 1/10.

POSTED BY: Marvin Ray Burns

If above this you see the title "Try to beat these MRB constant records!" in order to see the first 11 sections, you'll need to refresh the page.

MRB constant formulas and identities

I developed this informal catalog of formulas for the MRB constant with over 20 years of research and ideas from users like you.


6/7/2022

CMRB

=enter image description here

=enter image description here

=enter image description here

=enter image description here

=enter image description here

=enter image description here

So, using induction, we have. enter image description here

enter image description here

Sum[Sum[(-1)^(x + n), {n, 1, 5}] + (-1)^(x) x^(1/x), {x, 2, Infinity}]


3/25/2022

Formula (11) =

enter image description here

As Matheamatica says:

Assuming[Element[c, \[DoubleStruckCapitalZ]], FullSimplify[
     E^(t*(r + I*Pi*(2*c + 1))) /. r -> Log[t^(1/t) - 1]/t]]

= E^(I (1 + 2 c) [Pi] t) (-1 + t^(1/t)) enter image description here

Where for all integers c, (1+2c) is odd leading to enter image description here

Expanding the E^log term gives

enter image description here

which is enter image description here,

That is exactly (2) in the above-quoted MathWorld definition: enter image description here


2/21/2022

Directly from the formula of 12/29/2021 below, enter image description here In

u = (-1)^t; N[
NSum[(t^(1/t) - 1) u, {t, 1, Infinity }, WorkingPrecision -> 24, 
Method -> "AlternatingSigns"], 15]

Out[276]= 0.187859642462067

In

v = (-1)^-t - (-1)^t; 2 I N[
NIntegrate[Im[(t^(1/t) - 1) v^-1], {t, 1, Infinity I}, 
WorkingPrecision -> 24], 15]

Out[278]= 0.187859642462067

Likewise, enter image description here

Expanding the exponents,

enter image description here This can be generalized to (x+log/

Building upon that, we get a closed form for the inner integral in the following.

CMRB= enter image description here

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

In[2]:= CMRB - { 
 Quiet[Im[NIntegrate[
    Integrate[
     E^(Log[t]/t + x)/(-E^((-I)*Pi*t + x) + E^(I*Pi*t + x)), {x, 
      I, -I}], {t, 1, Infinity I}, WorkingPrecision -> 200, 
    Method -> "Trapezoidal"]]];
 Quiet[Im[NIntegrate[
    Integrate[
     Im[E^(Log[t]/t + x)/(-E^((-I)*Pi*t + x) + E^(I*Pi*t + x))], {x, 
      -t,  t }], {t, 1
     , Infinity  I}, WorkingPrecision -> 2000, 
    Method -> "Trapezoidal"]]]}

Out[2]= {3.*10^-998, 3.*10^-998}

Which after a little analysis, can be shown convergent in the continuum limit at t → ∞ i.



12/29/2021

From "Primary Proof 1" worked below, it can be shown that enter image description here

Mathematica knows that because

  m = N[NSum[-E^(I*Pi*t) + E^(I*Pi*t)*t^t^(-1), {t, 1, Infinity}, 
      Method -> "AlternatingSigns", WorkingPrecision -> 27], 18];
  Print[{m - 
     N[NIntegrate[
       Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(I \[Pi] t) - 
            E^(-I \[Pi] t))] I, {t, 1, -Infinity I}, 
       WorkingPrecision -> 20], 18], 
    m - N[NIntegrate[
       Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(-I \[Pi] t) - 
            E^(I \[Pi] t))] I, {t, 1, Infinity I}, 
       WorkingPrecision -> 20], 18], 
    m + 2 I*NIntegrate[
[(E^(I*Pi*t + Log[t]/t))/(-1 + E^((2*I)*Pi*t))], {t, 1, 
        Infinity I}, WorkingPrecision -> 20]}]

yields

  {0.*^-19,0.*^-19,0.*^-19}

Partial sums to an upper limit of (10^n i) give approximations for the MRB constant + the same approximation *10^-(n+1) i. Example:

-2 I*NIntegrate[
  Im[(E^(I*Pi*t + Log[t]/t))/(-1 + E^((2*I)*Pi*t))], {t, 1, 10^7 I}, 
  WorkingPrecision -> 20]

gives 0.18785602000738908694 + 1.878560200074*10^-8 I where CMRB ≈ 0.187856.

Notice it is special because if we integrate only the numerator, we have MKB=enter image description here, which defines the "integrated analog of CMRB" (MKB) described by Richard Mathar in https://arxiv.org/abs/0912.3844. (He called it M1.)

Like how this:

NIntegrate[(E^(I*Pi*t + Log[t]/t)), {t, 1, Infinity I}, 
  WorkingPrecision -> 20] - I/Pi

converges to

0.070776039311528802981 - 0.68400038943793212890 I.

(The upper limits " i infinity" and " infinity" produce the same result in this integral.)



11/14/2021

Here is a standard notation for the above mentioned

CMRB,enter image description here enter image description here.

In[16]:= CMRB = 0.18785964246206712024851793405427323005590332204; \
CMRB - NSum[(Sum[
    E^(I \[Pi] x) Log[x]^n/(n! x^n), {x, 1, Infinity}]), {n, 1, 20}, 
  WorkingPrecision -> 50]

Out[16]= -5.8542798212228838*10^-30

In[8]:= c1 = 
 Activate[Limit[(-1)^m/m! Derivative[m][DirichletEta][x] /. m -> 1, 
   x -> 1]]

Out[8]= 1/2 Log[2] (-2 EulerGamma + Log[2])

In[14]:= CMRB - 
 N[-(c1 + Sum[(-1)^m/m! Derivative[m][DirichletEta][m], {m, 2, 20}]), 
  30]

Out[14]= -6.*10^-30


11/01/2021

: The catalog now appears complete, and can all be proven through Primary Proof 1, and the one with the eta function, Primary Proof 2, both found below.

a ≠b enter image description here enter image description here

g[x_] = x^(1/x); CMRB = 
 NSum[(-1)^k (g[k] - 1), {k, 1, Infinity}, WorkingPrecision -> 100, 
  Method -> "AlternatingSigns"]; a = -Infinity I; b = Infinity I; 
g[x_] = x^(1/x); (v = t/(1 + t + t I);
 Print[CMRB - (-I /2 NIntegrate[ Re[v^-v Csc[Pi/v]]/ (t^2), {t, a, b},
       WorkingPrecision -> 100])]); Clear[a, b]
    -9.3472*10^-94

Thus, we find

enter image description here

here, and enter image description here next:

In[93]:= CMRB = 
 NSum[Cos[Pi n] (n^(1/n) - 1), {n, 1, Infinity}, 
  Method -> "AlternatingSigns", WorkingPrecision -> 100]; Table[
 CMRB - (1/2 + 
    NIntegrate[
     Im[(t^(1/t) - t^(2 n))] (-Csc[\[Pi] t]), {t, 1, Infinity I}, 
     WorkingPrecision -> 100, Method -> "Trapezoidal"]), {n, 1, 5}]

Out[93]= {-9.3472*10^-94, -9.3473*10^-94, -9.3474*10^-94, \
-9.3476*10^-94, -9.3477*10^-94}

CNT+F "The following is a way to compute the" for more evidence

For such n, enter image description here converges to 1/2+0i.

(How I came across all of those and more example code follow in various replies.)



On 10/18/2021

, I found the following triad of pairs of integrals summed from -complex infinity to +complex infinity.

CMRB= -complex infinity to +complex infinity

You can see it worked in this link here.

In[1]:= n = {1, 25.6566540351058628559907};

In[2]:= g[x_] = x^(n/x);
-1/2 Im[N[
   NIntegrate[(g[(1 - t)])/(Sin[\[Pi] t]), {t, -Infinity I, 
     Infinity I}, WorkingPrecision -> 60], 20]]

Out[3]= {0.18785964246206712025, 0.18785964246206712025}

In[4]:= g[x_] = x^(n/x);
1/2 Im[N[NIntegrate[(g[(1 + t)])/(Sin[\[Pi] t]), {t, -Infinity I, 
     Infinity I}, WorkingPrecision -> 60], 20]]

Out[5]= {0.18785964246206712025, 0.18785964246206712025}

In[6]:= g[x_] = x^(n/x);
1/4 Im[N[NIntegrate[(g[(1 + t)] - (g[(1 - t)]))/(Sin[\[Pi] t]), {t, -Infinity I, 
     Infinity I}, WorkingPrecision -> 60], 20]]

Out[7]= {0.18785964246206712025, 0.18785964246206712025}

Therefore, bringing

enter image description here

back to mind, we joyfully find,

CMRB n and 1

In[1]:= n = 
  25.65665403510586285599072933607445153794770546058072048626118194900\
97321718621288009944007124739159792146480733342667`100.;

g[x_] = {x^(1/x), x^(n/x)};

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

Print[CMRB - 
  NIntegrate[Im[g[(1 + I t)]/Sinh[\[Pi] t]], {t, 0, Infinity}, 
   WorkingPrecision -> 100], u = (-1 + t); v = t/u;
 CMRB - NIntegrate[Im[g[(1 + I v)]/(Sinh[\[Pi] v] u^2)], {t, 0, 1}, 
   WorkingPrecision -> 100], 
 CMRB - NIntegrate[Im[g[(1 - I v)]/(Sinh[-\[Pi] v] u^2)], {t, 0, 1}, 
   WorkingPrecision -> 100]]

During evaluation of In[1]:= {-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}{-9.3472*10^-94,-9.3472*10^-94}

In[23]:= Quiet[
 NIntegrate[
  Im[g[(1 + I t)]/Sinh[\[Pi] t] - 
    g[(1 + I v)]/(Sinh[\[Pi] v] u^2)], {t, 1, Infinity}, 
  WorkingPrecision -> 100]]

Out[23]= -3.\
9317890831820506378791034479406121284684487483182042179057328100219696\
20202464096600592983999731376*10^-55

In[21]:= Quiet[
 NIntegrate[
  Im[g[(1 + I t)]/Sinh[\[Pi] t] - 
    g[(1 - I v)]/(Sinh[-\[Pi] v] u^2)], {t, 1, Infinity}, 
  WorkingPrecision -> 100]]

Out[21]= -3.\
9317890831820506378791034479406121284684487483182042179057381396998279\
83065832972052160228141179706*10^-55

In[25]:= Quiet[
 NIntegrate[
  Im[g[(1 + I t)]/Sinh[\[Pi] t] + 
    g[(1 + I v)]/(Sinh[-\[Pi] v] u^2)], {t, 1, Infinity}, 
  WorkingPrecision -> 100]]

Out[25]= -3.\
9317890831820506378791034479406121284684487483182042179057328100219696\
20202464096600592983999731376*10^-55


On 9/29/2021

I found the following equation for CMRB (great for integer arithmetic because

(1-1/n)^k=(n-1)^k/n^k. )

CMRB integers 1

So, using only integers, and sufficiently large ones in place of infinity, we can use

CMRB integers 2

See

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

Out[1]= 0.086374

In[2]:= Timing[m-NSum[(-1)^n/x! (Sum[((-1 + n)^k) /(k n^(1 + k)), {k, 1, Infinity}])^ x, {n, 2, Infinity}, {x, 1,100}, Method -> "AlternatingSigns",  WorkingPrecision -> 200, NSumTerms -> 100]]

Out[2]= {17.8915,-2.2*^-197}

It is very much slower, but it can give a rational approximation (p/q), like in the following.

In[3]:= mt=Sum[(-1)^n/x! (Sum[((-1 + n)^k) /(k n^(1 + k)), {k, 1,500}])^ x, {n, 2,500}, {x, 6}];

In[4]:= N[m-mt]

Out[4]= -0.00602661

In[5]:= Head[mt]

Out[5]= Rational

Compared to the NSum formula for m, we see

In[6]:= Head[m]

Out[6]= Real


On 9/19/2021

I found the following quality of CMRB.

replace constants for CMRB



On 9/5/2021

I added the following MRB constant integral over an unusual range.

strange

See proof in this link here.



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

I added a new MRB constant integral.

CMRB = integral to sum

We see many more integrals for CMRB.

We can expand 1/x into the following.

xx = 25.656654035

xx = 25.65665403510586285599072933607445153794770546058072048626118194\
90097321718621288009944007124739159792146480733342667`100.;


g[x_] = x^(xx/
    x); I NIntegrate[(g[(-t I + 1)] - g[(t I + 1)])/(Exp[Pi t] - 
           Exp[-Pi t]), {t, 0, Infinity}, WorkingPrecision -> 100]

 (*
0.18785964246206712024851793405427323005590309490013878617200468408947\
72315646602137032966544331074969.*)

Expanding upon the previously mentioned

enMRB sinh

we get the following set of formulas that all equal CMRB:

Let

x= 25.656654035105862855990729 ...

along with the following constants (approximate values given)

{u = -3.20528124009334715662802858},

{u = -1.975955817063408761652299},

{u = -1.028853359952178482391753},

{u = 0.0233205964164237996087020},

{u = 1.0288510656792879404912390},

{u = 1.9759300365560440110320579},

{u = 3.3776887945654916860102506},

{u = 4.2186640662797203304551583} or

$ u = \infty .$

then

enter image description here

See this notebook from the wolfram cloud

and this notebook

for justification. Also, there is symmetry between the local extrema of the left half of the plane with the right.



2020 and before:

Also, in terms of the Euler-Riemann zeta function,

CMRB =enter image description here

Furthermore, as enter image description here,

according to user90369 at Stack Exchange, CMRB can be written as the sum of zeta derivatives similar to the eta derivatives discovered by Crandall. zeta hint Information about η(j)(k) please see e.g. this link here, formulas (11)+(16)+(19).credit



In the light of the parts above, where

CMRB

= k^(1/k)-1

= eta'(k)

= sum from 0 enter image description here as well as double equals RHS an internet scholar going by the moniker "Dark Malthorp" wrote:

eta *z^k






Primary Proof 1

CMRB=enter image description here, based on

CMRB eta equals enter image description here

is proven below by an internet scholar going by the moniker "Dark Malthorp."

Dark Marthorp's proof



Primary Proof 2

eta sums denoting the kth derivative of the Dirichlet eta function of k and 0 respectively, was first discovered in 2012 by Richard Crandall of Apple Computer.

The left half is proven below by Gottfried Helms and it is proven more rigorously(considering the conditionally convergent sum,enter image description here) below that. Then the right half is a Taylor expansion of eta(s) around s = 0.

n^(1/n)-1

At https://math.stackexchange.com/questions/1673886/is-there-a-more-rigorous-way-to-show-these-two-sums-are-exactly-equal,

it has been noted that "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.)"

argument 1 argument 2



Primary Proof 3

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

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-> infinity and apply equations [3] and [4] : QED He went on to note that

enter image description here





I wondered about the relationship between CMRB and its integrated analog and asked the following. enter image description here So far I came up with

Another relationship between the sum and integral that remains more unproven than I would like is

CMRB(1-i)

f[x_] = E^(I \[Pi] x) (1 - (1 + x)^(1/(1 + x)));
CMRB = NSum[f[n], {n, 0, Infinity}, WorkingPrecision -> 30, 
   Method -> "AlternatingSigns"];
M2 = NIntegrate[f[t], {t, 0, Infinity I}, WorkingPrecision -> 50];
part = NIntegrate[(Im[2 f[(-t)]] + (f[(-t)] - f[(t)]))/(-1 + 
      E^(-2 I \[Pi] t)), {t, 0, Infinity I}, WorkingPrecision -> 50];
CMRB (1 - I) - (M2 - part)

gives

6.10377910^-23 - 6.10377910^-23 I.

Where the integral does not converge, but Mathematica can give it a value:

enter image description here






Update 2015

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

enter image description here enter image description here enter image description here enter image description here enter image description here enter image description here see notebook

Likewise, Wolfram Alpha here says

enter image description here

It also adds

enter image description here

Interestingly,

enter image description here

That has the same argument, enter image description here, as the MeijerG transformation of CMRB. enter image description here

The next reply should say "

§13.

MRB Constant Records," If not refresh the page to see them.

POSTED BY: Marvin Ray Burns
POSTED BY: Marvin Ray Burns
POSTED BY: Marvin Ray Burns
Attachments:
POSTED BY: Marvin Ray Burns

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

The MRB constant supercomputer said,

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

"Processor time" 72.526 days

"Actual time" 185.491 days

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

POSTED BY: Marvin Ray Burns

Time for a quick memorial:

This discussion began on 1/20/2014.

"This MRB records posting reached a milestone of over 120,000 views on 3/31/2020, around 4:00 am."

"As of 04:00 am 1/2/2021, this discussion had 300,000 views!"

"And as of 08:30 pm 2/3/2021, this discussion had 330,000 views!"

"7:00 pm 10/8/2021 it had 520,000 views!"

1:40 am 3/2/2022 600,000 views

8:25 pm 5/4/2022 650,000 views

In the last seven months, this discussion has had as many visitors as it did in its first seven years!

1/20/2023 695,000 views in nine years. That's an average of 8.8 views/hour, or one view every 6.8 minutes.

1/15/2024 810,223 views in ten years. That's an average of 9.24 views/hour, or one view every 6.49 minutes.

POSTED BY: Marvin Ray Burns

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

While waiting for results on the 2nd try of calculating 6,500,000 digits of the MRB constant (CMRB), I thought I would compare the convergence rate of 3 different primary forms of it. They are listed from slowest to fastest.

POSTED BY: Marvin Ray Burns

WOW!!!!

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

Maybe a few more restrictions, like a≠b.

See cloud notebook.

enter image description here

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

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

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

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

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

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

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

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

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

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

Beyond any shadow of a doubt, I verified 5,609,880 digits of the MRB constant on Thu 4 Mar 2021 08:03:45. The 5,500,000+ digit computation using a totally different method showed about that many decimals in common with the 6,000,000+ digit computation. The method for the 6,000,000 run is found in a few messages above in the attached notebook titled "MRBSC2 6 million...nb."

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

       (**N[Exp[Log[ll]/ll],pr/396288]**)


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

         (**N[Exp[Log[ll]/ll],pr/65536]**)

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

             (*N[Exp[Log[ll]/ll],pr/16384]*)


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

         (*N[Exp[Log[ll]/ll],pr/4096]*)

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

               (*N[Exp[Log[ ll]/ll],pr/1024]*)

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

         (*N[Exp[Log[ ll]/ll],pr/256]*)

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

        (**N[Exp[Log[ ll]/ll],pr/64]**)

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

          (**N[Exp[Log[ ll]/ll],pr/16]**)

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

         (**N[Exp[Log[ll]/ll],pr/4]**)

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

       (*N[Exp[Log[ll]/ll],pr]*)

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

The 5,500,000+digit run is found below in the attached "5p5million.nb," including the verified 5,609,880 digits.

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

      (*N[Exp[Log[ll]/ll], pr/27]*)

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

      (*N[Exp[Log[ll]/ll], pr]*)

       x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 1]];
    ctab = Table[c = b - c;
      ll = start + l - 2;
      b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
      c, {l, chunksize}];
    s += ctab.(xvals - 1);
    start += chunksize;
    Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,
      end - 1}];
   N[-s/d, pr]];

t2 = Timing[MRBtest2 = expM[prec];];
N[MRBtest2 - MRB, 20]
Attachments:
POSTED BY: Marvin Ray Burns

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

Distribution of digits

Here is the distribution of digits within the first 6,000,000 decimal places (.187859,,,), "4" shows up more than other digits, followed by "0," "8" and "7."

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

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

...including arbitrarily close approximation formulas for CMRB

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 a closed-form exists for computing and checking the digits of m from n^m-m=a near integer and n is an integer.

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

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

In[63]:= 225897077238546^m - m

Out[63]= 496.99999999999999975304752932252481772179797865

In[62]:= 1668628852566227424415^m - m

Out[62]= 9700.9999999999999999994613109586919797992822178

In[61]:= 605975224495422946908^m - m

Out[61]= 8019.9999999999999999989515156294756517433387956

In[60]:= 3096774194444417292742^m - m

Out[60]= 10896.0000000000000000000000096284579090392932063

In[56]:= 69554400815329506140847^m - m

Out[56]= 19549.9999999999999999999999991932013520540825206

In[68]:= 470143509230719799597513239^m - m

Out[68]= 102479.000000000000000000000000002312496475978584

In[70]:= 902912955019451288364714851^m - m

Out[70]= 115844.999999999999999999999999998248770510754951

In[73]:= 2275854518412286318764672497^m - m

Out[73]= 137817.000000000000000000000000000064276966095482

In[146]:= 2610692005347922107262552615512^m - m

Out[146]= 517703.00000000000000000000000000000013473353420

In[120]:= 9917209087670224712258555601844^m - m

Out[120]= 665228.00000000000000000000000000000011062183643

In[149]:= 19891475641447607923182836942486^m - m

Out[149]= 758152.00000000000000000000000000000001559954712

In[152]:= 34600848595471336691446124576274^m - m

Out[152]= 841243.00000000000000000000000000000000146089062

In[157]:= 543136599664447978486581955093879^m - m

Out[157]= 1411134.0000000000000000000000000000000035813431

In[159]:= 748013345032523806560071259883046^m - m

Out[159]= 1498583.0000000000000000000000000000000031130944

In[162]:= 509030286753987571453322644036990^m - m

Out[162]= 1394045.9999999999999999999999999999999946679646


In[48]:= 952521560422188137227682543146686124^m - m

Out[48]=5740880.999999999999999999999999999999999890905129816474332198321490136628009367504752851478633240


In[26]:= 50355477632979244604729935214202210251^m - m

Out[26]=12097427.00000000000000000000000000000000000000293025439870097812782596113788024271834721860892874


In[27]:= 204559420776329588951078132857792732385^m - m

Out[27]=15741888.99999999999999999999999999999999999999988648448116819373537316944519114421631607853700001


In[46]:= 4074896822379126533656833098328699139141^m - m

Out[46]= 27614828.00000000000000000000000000000000000000001080626974885195966380280626150522220789167201350


In[8]:= 100148763332806310775465033613250050958363^m - m

Out[8]= 50392582.999999999999999999999999999999999999999998598093272973955371081598246


In[10]=  116388848574396158612596991763257135797979^m - m

Out[10]=51835516.000000000000000000000000000000000000000000564045501599584517036465406


In[12]:= 111821958790102917465216066365339190906247589^m - m

Out[12]= 188339125.99999999999999999999999999999999999999999999703503169989535000879619


In[33] := 8836529576862307317465438848849297054082798140^m - m

Out[33] = 42800817.00000000000000000000000000000000000000000000000321239755400298680819416095288742420653229


In[71] := 532482704820936890386684877802792716774739424328^m - m

Out[71] =924371800.999999999999999999999999999999999999999999999998143109316148796009581676875618489611792


In[21]:= 783358731736994512061663556662710815688853043638^m - m

Out[21]= 993899177.0000000000000000000000000000000000000000000000022361744841282020


In[24]:= 8175027604657819107163145989938052310049955219905^m - m

Out[24]= 1544126008.9999999999999999999999999999999999999999999999999786482891477\
944981


19779617801396329619089113017251584634275124610667^m - m
gives
1822929481.00000000000000000000000000000000000000000000000000187580971544991111083798248746369560.


130755944577487162248300532232643556078843337086375^m - m

gives 

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

(51 consecutive 9 s)

322841040854905412176386060015189492405068903997802^m - m

gives

3080353548.000000000000000000000000000000000000000000000000000019866002281287395703598786588650156

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

(52 consecutive 0 s)


310711937250443758724050271875240528207815041296728160^m - m

gives

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

(55 consecutive 9s)

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

(62 consecutive 9 s).

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

enter image description here as in https://www.wolframcloud.com/obj/7238e6f0-6fa5-4015-aaf5-1cca5c2670ca

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

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

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

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

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. 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 6 million checked digits are found in the attached file 3M.nb. (You will have to change the Format/Style to Input to use the digits.)

Download the following notebook and open in the Desktop:

https://www.wolframcloud.com/obj/bmmmburns/Published/Fast%20Burns%20check%20using%20Crandall.nb

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

Upon reading them, Google OpenAI Chat CPT wrote the following reply:

enter image description here

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

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

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

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

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

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.
Reply Preview
Attachments
Remove
or Discard

Group Abstract Group Abstract