Message Boards Message Boards

GROUPS:

Try to beat these MRB constant records!

Posted 8 years ago
674891 Views
|
73 Replies
|
17 Total Likes
|
POSTED BY: Marvin Ray Burns
73 Replies

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

and the words

Reply | Flag

at the same time,

you might have to refresh the page to see the first message. The first message is crucial for understanding the MRB constant, as most of the facts are there.



The following might help anyone serious about breaking my record.

Richard Crandall wrote about couple of new formulae for computing the MRB constant faster on pp 28 and 29 here. a true jewel of an expression Interestingly, as pointed out by J. Borwein,

By the way, I wrote Crandall about formula (44) -- it seems it should have a minus sign in front of it -- and he wrote back: enter image description here

POSTED BY: Marvin Ray Burns

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

Reply|Flag

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



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

POSTED BY: Marvin Ray Burns

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

enter image description here

The ultimate speed record to beat, though, is Ricahrd Crandall's (Chief cryptographer for Apple, 2012) 1,048,576 digits in a blistering fast 76.4 hours, while the Apple computation group(also in 2012) computed 1,000,000 digits of the MRB constant in a long 18 days 9 hours 11 minutes 34.253417 seconds, so progress vs time is not as linear as my results plotted above.

POSTED BY: Marvin Ray Burns

It is hard to be certain that c1 and c2 are correct to 77 digits even though they agree to that extent. I'm not saying that they are incorrect and presumably you have verified this. Just claiming that whatever methods NSum may be using to accelerate convergence, there is really no guarantee that they apply to this particular computation. So c1 aand c2 could agree to that many places because they are computed in a similar manner without all digits actually being correct.

POSTED BY: Daniel Lichtblau

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

POSTED BY: Marvin Ray Burns

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

enter image description hereenter image description here

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

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

 MRBtest2 = expM[prec]

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

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

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

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

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

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

0.18785964246206712024851793405427323005590309490013878617200468408947 723156466021370329665443310750

POSTED BY: Marvin Ray Burns

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

enter image description here

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

POSTED BY: Marvin Ray Burns

Tue 24 Apr 2018

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

enter image description here[41]

Sat 28 Apr 2018

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

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

enter image description here

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

table

Here are the 3 programs referenced in the above table:

All MRB:

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


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


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

Crandall

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

Hybrid

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

Aug 8 2018

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

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

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

.

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

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

See attached "58 hour million."

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

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


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


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

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

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

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


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

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

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

Iterations required: 1326598

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

Actual time was 192609.7247443

Enter MRBtest2 to print 1004992 digits

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

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

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

top bottom

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

01/08/2019

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

Attachments:
POSTED BY: Marvin Ray Burns

What Richard Crandall and maybe others did to come up with that method is really good and somewhat mysterious. I still don't really understand the inner workings, and I had shown him how to parallelize it. So the best I can say is that it's really hard to compete against magic. (I don't want to discourage others, I'm just explaining why I myself would be reluctant to tackle this. Someone less familiar might actually have a better chance of breaking new ground.)

In a way this should be good news. Should it ever become "easy" to compute, the MRB number would lose what is perhaps its biggest point of interest. It just happens to be on that cusp of tantalizingly "close" to easily computable (perhaps as sums of zeta function and derivatives thereof), yet still hard enough that it takes a sophisticated scheme to get more than a few dozen digits.

POSTED BY: Daniel Lichtblau

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

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

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

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

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

POSTED BY: Marvin Ray Burns

I can't say I understand either. My guess is the Eta stuff comes from summing (-1)^k*(Log[k]/k)^n over k, as those are the terms that appear in the double sum you get from expanding k^(1/k)-1 in powers of Log[k]/k (use k^(1/k)=Exp[Log[k]/k] and the power series for Exp). Even if it does come from this the details remain elusive..

POSTED BY: Daniel Lichtblau

Daniel Lichtblau and others, Richard Crandall did intend to explian his work on the MRB constant and his program to compute it. When I wrote him with a possible small improvement to his program he said, "It's worth observing when we write it up." See screenshot: enter image description here

POSTED BY: Marvin Ray Burns

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

Going back to Crandall's code:

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

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

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

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

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

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

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

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

POSTED BY: Marvin Ray Burns

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

POSTED BY: Daniel Lichtblau

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

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

Please be patient...

rec

Sent from my iPhone."

POSTED BY: Marvin Ray Burns

Jan 2015

How about computing the MRB constant from Crandall's eta derivative formulas? They are mentioned in a previous post but here they are again:

enter image description here

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

In[37]:= mm = 
  0.187859642462067120248517934054273230055903094900138786172004684089\
4772315646602137032966544331074969038423458562580190612313700947592266\
3043892934889618412083733662608161360273812637937343528321255276396217\
1489321702076282062171516715408412680448363541671998519768025275989389\
9391445798350556135096485210712078444230958681294976885269495642042555\
8648367044104252795247106066609263397483410311578167864166891546003422\
2258838002545539689294711421221891050983287122773080200364452153905363\
9505533220347062755115981282803951021926491467317629351619065981601866\
4245824950697203381992958420935515162514399357600764593291281451709082\
4249158832041690664093344359148067055646928067870070281150093806069381\
3938595336065798740556206234870432936073781956460310476395066489306136\
0645528067515193508280837376719296866398103094949637496277383049846324\
5634793115753002892125232918161956269736970748657654760711780171957873\
6830096590226066875365630551656736128815020143875613668655221067430537\
0591039735756191489093690777983203551193362404637253494105428363699717\
0244185516548372793588220081344809610588020306478196195969537562878348\
1233497638586301014072725292301472333336250918584024803704048881967676\
7601198581116791693527968520441600270861372286889451015102919988536905\
7286592870868754254925337943953475897035633134403826388879866561959807\
3351473990256577813317226107612797585272274277730898577492230597096257\
2562718836755752978879253616876739403543214513627725492293131262764357\
3214462161877863771542054231282234462953965329033221714798202807598422\
1065564890048536858707083268874877377635047689160983185536281667159108\
4121934201643860002585084265564350069548328301205461932`1661.\
273833491444;

In[30]:= Timing[
 etaMM[m_, pr_] := 
  Module[{a, d, s, k, b, c}, a[j_] := Log[j + 1]^m/(j + 1)^m;
   n = Floor[1.32 pr];
   d = Cos[n ArcCos[3]];
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   N[s/d, pr] (-1)^m];
 eta[s_] := (1 - 2^(1 - s)) Zeta[s];
 eta1 = Limit[D[eta[s], s], s -> 1];
 MRBtrue = mm;
 prec = 500;
 MRBtest = 
  eta1 - Sum[(-1)^m etaMM[m, prec]/m!, {m, 2, Floor[.45 prec]}];
 MRBtest - MRBtrue]

Out[30]= {36.831836, 0.*10^-502}

Here is a short table of computation times with that program:

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453

I just now retweaked the program. It is now

Timing[etaMM[m_, pr_] := 
  Module[{a, d, s, k, b, c}, 
   a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr];
   n = Floor[1.32 pr];
   d = Cos[n ArcCos[3]];
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
 eta[s_] := (1 - 2^(1 - s)) Zeta[s];
 eta1 = Limit[D[eta[s], s], s -> 1];
 MRBtrue = mm;
 prec = 1500;
 MRBtest = 
  eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, 
     Floor[.45 prec]}, Method -> "Procedural"];
 MRBtest - MRBtrue]

Feb 2015

Here are my best eta derivative records:

Digits        Seconds
 500          9.874863
 1000        62.587601
 1500        219.41540
 2000       1008.842867
 2500       2659.208646
 3000       5552.902395
 3500       10233.821601

That is using V10.0.2.0 Kernel. Here is a sample

Timing[etaMM[m_, pr_] := 
          Module[{a, d, s, k, b, c}, 
           a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr];
           n = Floor[1.32 pr];
           d = Cos[n ArcCos[3]];
           {b, c, s} = {-1, -d, 0};
           Do[c = b - c;
            s = s + c a[k];
            b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}];
           Return[N[s/d, pr] (-1)^m]];
         eta[s_] := (1 - 2^(1 - s)) Zeta[s];
         eta1 = Limit[D[eta[s], s], s -> 1];
         MRBtrue = mm;
         prec = 500;
         MRBtest = 
          eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, 
             Floor[.45 prec]}];
        ]
         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         General::stop: Further output of N::meprec will be suppressed during this calculation.

         Out[1]= {9.874863, Null}

Aug 2016

enter image description here

V 11 has a significant improvement in my new most recently mentioned fastest program for calculating digits of the MRB constant via the eta formula, Here are some timings:

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275



 10,000        53667.6315476

From an previous message that starts with "How about computing the MRB constant from Crandall's eta derivative formulas?" here are my first two sets of records to compare with the just mentioned ones. You can see that I increased time efficiency by 10 to 29 to even 72 fold for select computations! In the tests used in that "previous message," 4000 or more digit computations produced a seemingly indefinitely long hang-on.

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453


Digits        Seconds
 500          9.874863
 1000        62.587601
 1500        219.41540
 2000       1008.842867
 2500       2659.208646
 3000       5552.902395
 3500       10233.821601

Comparing first of the just mentioned 2000 digit computations with the "significant improvement" one we get the following.

3752/127 ~=29.

And from the slowest to the fastest 1500 digit run we get

2989/42 ~=72,

POSTED BY: Marvin Ray Burns

02/12/2019

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

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

SessionTime[] - to

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

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

3/28/2019

Here is an updated table of speed eta formula records: eta records 12 31 18

04/03/2019

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

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

SessionTime[] - to

 (* 0.*10^-50000

  500808.4835750*)
POSTED BY: Marvin Ray Burns

4/22/2019

Let $$M=\sum _{n=1}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right).$$ Then using what I learned about the absolute convergence of $\sum _{n=1}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}$ from https://math.stackexchange.com/questions/1673886/is-there-a-more-rigorous-way-to-show-these-two-sums-are-exactly-equal, combined with an identity from Richard Crandall: enter image description here, Also using what Mathematica says:

$$\sum _{n=1}^1 \frac{\underset{m\to 1}{\text{lim}} \eta ^n(m)}{n!}=\gamma (2 \log )-\frac{2 \log ^2}{2},$$

I figured out that

$$\sum _{n=2}^{\infty } \frac{(-1)^{n+1} \eta ^n(n)}{n!}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-\frac{\log (n)}{n}-1\right).$$

So I made the following major breakthrough in computing MRB from Candall's first eta formula. See attached 100 k eta 4 22 2019. Also shown below.

eta 18 to19 n 2.JPG

The time grows 10,000 times slower than the previous method!

I broke a new record, 100,000 digits: Processor and total time were 806.5 and 2606.7281972 s respectively.. See attached 2nd 100 k eta 4 22 2019.

Here is the work from 100,000 digits. enter image description here

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


 (Start time is )^2Tue 23 Apr 2019 06:49:31.

 Iterations required: 132026

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

 Will stop at 133120 iterations to ensure precsion of around 100020 decimal places.

 Denominator computed in  17.2324041s.

...

129024 iterations done in 1011. seconds. Should take 0.01203 days or 1040.s, finish Mon 22 Apr 
2019 12:59:16.

131072 iterations done in 1026. seconds. Should take 0.01202 days or 1038.s, finish Mon 22 Apr 
2019 12:59:15.

Finished on Mon 22 Apr 2019 12:59:03. Processor time was 786.797 s.

enter image description here

 Print["Start time is " "Start time is ", ds = DateString[], "."];
 prec = 100000;
 (**Number of required decimals.*.*)ClearSystemCache[];
 T0 = SessionTime[];
 expM[pre_] := 
   Module[{lg, a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=
     4*number of physical cores*), tsize = 2^7, chunksize, start = 1, 
     ll, ctab, pr = Floor[1.0002 pre]}, chunksize = cores*tsize;
    n = Floor[1.32 pr];
    end = Ceiling[n/chunksize];
    Print["Iterations required: ", n];
    Print["Will give ", end, 
     " time estimates, each more accurate than the previous."];
    Print["Will stop at ", end*chunksize, 
     " iterations to ensure precsion of around ", pr, 
     " decimal places."]; d = ChebyshevT[n, 3];
    {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
    iprec = pr/2^6;
    Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
         lg = Log[ll]/(ll); x = N[E^(lg), iprec];
         pc = iprec;
         While[pc < pr, pc = Min[4 pc, pr];
          x = SetPrecision[x, pc];
          xll = x^ll; z = (ll - xll)/xll;
          t = 2 ll - 1; t2 = t^2;
          x = 
           x*(1 + SetPrecision[4.5, pc] (ll - 1)/
                t2 + (ll + 1) z/(2 ll t) - 
              SetPrecision[13.5, 2 pc] ll (ll - 1)/(3 ll t2 + t^3 z))];
          x - lg, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
        Method -> "EvaluationsPerKernel" -> 16]];
     ctab = ParallelTable[Table[c = b - c;
        ll = start + l - 2;
        b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
        c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16];
     s += ctab.(xvals - 1);
     start += chunksize;
     st = SessionTime[] - T0; kc = k*chunksize;
     ti = (st)/(kc + 10^-10)*(n)/(3600)/(24);
     If[kc > 1, 
      Print[kc, " iterations done in ", N[st - stt, 4], " seconds.", 
       " Should take ", N[ti, 4], " days or ", ti*3600*24, 
       "s, finish ", DatePlus[ds, ti], "."], 
      Print["Denominator computed in  ", stt = st, "s."]];, {k, 0, 
      end - 1}];
    N[-s/d, pr]];
 t2 = Timing[MRBeta2toinf = expM[prec];]; Print["Finished on ", 
  DateString[], ". Processor and total time were ", 
  t2[[1]], " and ", st, " s respectively."];

Start time is  Tue 23 Apr 2019 06:49:31.

Iterations required: 132026

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

Will stop at 133120 iterations to ensure precision of around 100020 decimal places.

Denominator computed in  17.2324041s.

...

131072 iterations done in 2589. seconds. Should take 0.03039 days or 2625.7011182s, finish Tue 23 Apr 2019 07:33:16.

Finished on Tue 23 Apr 2019 07:32:58. Processor and total time were 806.5 and 2606.7281972 s respectively.

enter image description here

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

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

enter image description here

   N[MRBeta2toinf + MRBeta1 - MRB, 10]

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

I figured out how to rapidly compute AND CHECK a computation of the MRB constant! (The timing given is in processor time [for computing and checking] only. T0 can be used with another SessionTime[] call at the end to figure out all time expired during running of the program.) I used both of Crandall's methods for computing it and used for a check, the nontrivial identityenter image description here ,where gamma is the Euler constant and M is the MRB constant.

Below is my first version of the code with results. If nothing else, I thought, the code pits Crandall's 2 methods against each other to show if one is wrong they both are wrong. (So it is not a real proof.) But these are two totally different methods! (the first of which has been proven by Henry Cohen to be theoretically correct here). For a second check mm is a known approximation to the constant; over 3 million non checked (as of now) digits are found in the attached file 3M.nb. (You will have to change the Format/Style to Input to use the digits.)

In[15]:= (*MRB constant computation with verification! The constant's \
decimal approximation is saved as MRBtest*)prec = 5000;(*Number of \
required decimals.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
 Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, 
   tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]},
   chunksize = cores*tsize;
  n = Floor[1.32 pr];
  end = Ceiling[n/chunksize];
  d = N[(3 + Sqrt[8])^n, pr + 10];
  d = Round[1/2 (d + 1/d)];
  {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
  iprec = Ceiling[pr/27];
  Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],
        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 1]];
    ctab = Table[c = b - c;
      ll = start + l - 2;
      b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
      c, {l, chunksize}];
    s += ctab.(xvals - 1);
    start += chunksize;, {k, 0, end - 1}];
  etaMs = N[-s/d - (EulerGamma Log[2] - Log[2]^2/2), pr]]; t2 = 
 Timing[MRBtest2 = expM[prec];];
Print["The MRB constant was computed and checked to ", prec, " digits \
in ", t1 = t2[[1]] + Timing[eta[s_] := (1 - 2^(1 - s)) Zeta[s];
     eta1 = Limit[D[eta[s], s], s -> 1];
     MRBtrue = mm;
     MRBtest = eta1 + etaMs;
     check = MRBtest - MRBtrue][[1]], " seconds"]; check

During evaluation of In[15]:= The MRB constant was computed and checked to 5000 digits in 2.12161 seconds

Out[18]= 0.*10^-5000

In[19]:= MRBtest - mm

Out[19]= 0.*10^-5000
Attachments:
POSTED BY: Marvin Ray Burns

The identity in question is straightforward. Write n^(1/n) as Exp[Log[n]/n], take a series expansion at 0, and subtract the first term from all summands. That means subtracting off Log[n]/n in each summand. This gives your left hand side. We know it must be M - the sum of the terms we subtracted off. Now add all of them up, accounting for signs.

Expand[Sum[(-1)^n*Log[n]/n, {n, 1, Infinity}]]

(* Out[74]= EulerGamma Log[2] - Log[2]^2/2 *)

So we recover the right hand side.

I have not understood whether this identity helps with Crandall's iteration. One advantage it confers, a good one in general, is that it converts a conditionally convergent alternating series into one that is absolutely convergent. From a numerical computation point of view this is always good.

POSTED BY: Daniel Lichtblau

Daniel Lichtblau and others, I just deciphered an Identity Crandall used for checking computations of the MRB constant just before he died. It is used in a previous post about checking, where I said it was hard to follow. The MRB constant is B here. B=`enter image description here In input form that is

   B= Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
         Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] + 
     1/24 (\[Pi]^2 Log[2]^2 - 
        2 \[Pi]^2 Log[
          2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
        6 (Zeta^\[Prime]\[Prime])[2]) + 
     1/2 (2 EulerGamma Log[2] - Log[2]^2)

For 3000 digit numeric approximation, it is

B=NSum[((-1)^(
    k + 1) (-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
      Log[1 + k]^2/(2 (1 + k)^2))), {k, 0, Infinity}, 
  Method -> "AlternatingSigns", WorkingPrecision -> 3000] + 
 1/24 (\[Pi]^2 Log[2]^2 - 
    2 \[Pi]^2 Log[
      2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
    6 (Zeta^\[Prime]\[Prime])[2]) + 
 1/2 (2 EulerGamma Log[2] - Log[2]^2)

It is anylitaclly straight forward too because

Sum[(-1)^(k + 1)*Log[1 + k]^2/(2 (1 + k)^2), {k, 0, Infinity}]

gives

1/24 (-\[Pi]^2 (Log[2]^2 + EulerGamma Log[4] - 
      24 Log[2] Log[Glaisher] + Log[4] Log[\[Pi]]) - 
   6 (Zeta^\[Prime]\[Prime])[2])

That is enter image description here I wonder why he chose it?

POSTED BY: Marvin Ray Burns

The new sum is this.

Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
         Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] 

That appears to be the same as for MRB except now we subtract two terms from the series expansion at the origin of k^(1/k). For each k these terms are Log[k]/k + 1/2*(Log[k]/k)^2. Accounting for the signs (-1)^k and summing, as I did earlier for just that first term, we get something recognizable.

Sum[(-1)^(k)*(Log[k]/(k) + Log[k]^2/(2*k^2)), {k, 1, Infinity}]

(* Out[21]= 1/24 (24 EulerGamma Log[2] - 2 EulerGamma \[Pi]^2 Log[2] - 
   12 Log[2]^2 - \[Pi]^2 Log[2]^2 + 24 \[Pi]^2 Log[2] Log[Glaisher] - 
   2 \[Pi]^2 Log[2] Log[\[Pi]] - 6 (Zeta^\[Prime]\[Prime])[2]) *)

So what does this buy us? For one thing, we get even better convergence from brute force summation, because now our largest terms are O((logk/k)^3) and alternating (which means if we sum in pairs it's actually O~(1/k^4) with O~ denoting the "soft-oh" wherein one drops polylogarithmic factors).

How helpful is this? Certainly it cannot hurt. But even with 1/k^4 size terms, it takes a long time to get even 40 digits, let alone thousands. So there is more going on in that Crandall approach.

POSTED BY: Daniel Lichtblau

The MRB constant is now a Scholar subject:

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

POSTED BY: Marvin Ray Burns

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

enter image description here

Attachments are still here, though.

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

nice system!

POSTED BY: l van Veen
POSTED BY: Marvin Ray Burns

Would anyone let me know how this comes out on your computer?

Here is a link to my Nov 16, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 18, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 19, 2018 update of calculating 4 million digits of MRB: HERE,

Here is a link to my Nov 20, 2018 update of calculating 4 million digits of MRB: HERE

Here is a link to my Nov 21, 2018 update of calculating 4 million digits of MRB: HERE

Here is a link to my Nov 22, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 24, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 27, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Dec 05, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Dec 10, 2018 update of calculating 4 million digits of MRB: HERE.

Last update of 2018

5:37:20 pm EST | Monday, December 31, 2018 (49.04 days from start time), 75.2315 percent completed . 3,024,300 digits computed.3993600 iterations done in 4.23810^6 seconds. Should take 65.18 days or 5.63110^6s, finish Wed 16 Jan 2019 20:57:47. (16.64 days from now).

Probably the last update

12:47:20 am EST | Monday, January 14, 2019 (62.3495 days from start time), 95.679 percent completed . 3,846,295 digits computed. 5079040 iterations done in 5.38710^6 seconds. Should take 65.15 days or 5.62910^6s, finish Wed 16 Jan 2019 20:13:07. (2.81 days from now).

POSTED BY: Marvin Ray Burns

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

See attached notebook.

Watch my reaction here.

Attachments:
POSTED BY: Marvin Ray Burns

Attempts at a 5,000,000 digit calculation


First effort: Tue 22 May 2018

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

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

Here are some of the results:

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

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

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

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

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

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

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

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

Iterations required: 6632998

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

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

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

![enter image description here][1]

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

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

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

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

Third effort: 5/3/2019

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

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

Iterations required: 6632998

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

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

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

Wish me luck!

Here is the latest output:

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

{1,% done.}

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

{2,% done.}

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

{2,% done.}

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

{2,% done.}

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

{2,% done.}.

Followed by

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

{2,% done.}

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

{2,% done.}

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

{3,% done.}

Followed by

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

{3,% done.}

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

{4,% done.}

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

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

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

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{0,% done.}

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

{4,% done.}

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

...

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

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

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

{98,% done.}

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

{99,% done.}

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

{99,% done.}

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

Actual time was 5.5409619988176*10^6

Enter MRBtest2 to print 5024991 digits


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

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

processor time was 40 days

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

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

POSTED BY: Marvin Ray Burns

3/23/2019

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

Added to my cluster of

3.7 GH overclocked up to 4.7 GHz on all Intel 6 cores at 3000 MHz RAM

and 4 cores of 3.6 GHz at 2400 MHz RAM,

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

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

Total: $2,695.00.

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

3 node MRB Digital Storm 2

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

enter image description here

Attachments:
POSTED BY: Marvin Ray Burns

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

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

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

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

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

There seems to be a major problem with calculating 6,000,000 digits via my program. The problem is reproducible -- the kernel went offline at the same time in both tries.

I'm not sure about my next step!!!!!!!

UPDATE

I'm experimenting with virtual RAM. I created a 64 to 128 GB virtual RAM page and started the computation again on Mon 7 Oct 2019 20:50:12. Here are some random moments where I recorded the memory usage:

enter image description here enter image description here 5:36:52 pm EDT | Saturday, October 26, 2019:

{15,% done.}

1273856 iter. done in 1.630*10^6 s. Ave. 0.78157iter./s. Should take 117.87 days or 1.018*10^7s. Finish Sun 2 Feb 2020 17:45:26.

{16,% done.}

...

7:10:12 pm CST | Tuesday, November 26, 2019:

{42,% done.}

3424256 iter. done in 4.314*10^6 s. Ave. 0.79375iter./s. Should take 116.06 days or 1.003*10^7s. Finish Fri 31 Jan 2020 22:20:28.

{43,% done.}

More to come.

POSTED BY: Marvin Ray Burns

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

Attachments:
POSTED BY: Marvin Ray Burns

Breaking News

At https://math.stackexchange.com/questions/2564705/what-are-some-working-models-that-are-a-fit-the-formula-for-the-mrb-constant/3505694#3505694, an internet scholar going by the user name Dark Malthorp found the following formulas for CMRB. Some may be useful for breaking new records.

I'm particularly am fond of CMRB=enter image description here.

It seems to be true, as shown next.

  Quiet[
 Timing[mi = 
    NIntegrate[
     Im[(1 + I t)^(1/(1 + I t))]/Sinh[Pi t], {t, 0, Infinity}, 
     WorkingPrecision -> 1000, Method -> "Trapezoidal"]][[1]]]

gives 5.29688 seconds.

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

gives 0.234375 seconds.

 mi - ms

gives -3.*10^-998.

enter image description here enter image description here

POSTED BY: Marvin Ray Burns

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

enter image description here

Here is the code:

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

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

Then compute the integral.

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

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

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

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

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

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

code

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

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

2/27/2020 at 9:15 PM:

I just now started15,000 and a 20,000 digit computations of the integral form of the MRB constant. The 15,000 digit calculation of the MRB constant through the integral,enter image description here finished in 15,581s (4.328 hours) and was correct to all 15,000 digits!!!!!!!

I also calculated 20,000 correct digits in 51,632s (14.34 hr) using the integral code

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

Furthermore, I calculated 25,000 correct digits in 77,212.9s (21.45 hr) using the integral code

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

I think that does wonders to confirm the true approximated value of the constant. As calculated by both

enter image description here and enter image description here to at least 25,000 decimals, the true value of the MRB constant is

ms=mi≈ [Attached "MRB to 25k confirmed digits.txt"].

Computation and check of 25k digit integral calculation found in "comp of 25k confirmed digits.nb".

As 0f March 2, 2020, I'm working on timed calculations of 30k,50k and 100k digits of the integral. enter image description here

I finished a 30,000 accurate digit computation of the MRB constant via an integral in 78 hours. See "comp of 25k and 30k confirmed digits b.nb" for the digits and program.

Also, I finished a 50,000 accurate digit computation of the MRB constant via an integral in 6.48039 days. See "up to 50k digits of a MRB integral.nb" for the digits and program.

POSTED BY: Marvin Ray Burns

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

Here is the code:

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

I attached the notebook with the results.

Attachments:
POSTED BY: Marvin Ray Burns

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

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

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

 ...

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

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

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

The internet connection between my computers went out again!

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

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

So I restarted the computation on a single computer.

I'm using basically the same code as before.

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

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

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

17.7 "percent done"

POSTED BY: Marvin Ray Burns

In the same vein of a non-trivial approximation:

The MRB constant =m.

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

We know from previous posts, M=integral

To find how fast this integral converges to m, I entered

lsmall = Table[
  m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x},
     WorkingPrecision -> 40], {x, 1, 20}]; N[Ratios[1/lsmall], 15]

followed by the slower

lbig = Table[
  m - NIntegrate[Csch[\[Pi] t] Im[(1 + I t)^(1/(1 + I t))], {t, 0, x},
     WorkingPrecision -> 240], {x, 101, 120}]; N[Ratios[1/lbig], 15]

and ended up with values that converged to

23.2958716448535.

Using those ratios, it looks like

m-int/m-int

Since that is a form of 0/0, we can use L'Hospital's Rule and see that it is true:

Limit[(Csch[\[Pi] t] Im[(1 + I t)^(1/(
     1 + I t))])/(Csch[\[Pi] (t + 1)] Im[(1 + I (t + 1))^(1/(
     1 + I ( t + 1)))]), t -> Infinity]

gives

etopi

Now for the part that is similar to the approximations mentioned in the immediate, previous post.

You may know that

N[20/(E^Pi - Pi), 9]

gives

1.00004500.

While

N[2 - 100/(E^Pi/m - E^Pi), 8]

gives

1.0004005.

Furthermore,

N[2 - 100/(E^Pi/m - E^Pi), 12]/N[20/(E^Pi - Pi), 12]

gives

1.00035544632.

While

N[3 - 100/(E^Pi/m - E^Pi), 12] - N[20/(E^Pi - Pi), 12]

gives

1.00035546231.

Holy double, double vision Batman!

There is a way to make the approximations of 20/(E^Pi - Pi) vs 2 - 100/(E^Pi/x - E^Pi), where x is a relation to m, equal to 11 digits, instead of just similar to 9,

using the parking constant. E^Pi is involved in a term again! (The term is a Cosmological constant, of sorts.)

(*parking constant,c*)
c = NIntegrate[
   E^(-2*(EulerGamma + Gamma[0, t] + Log[t])), {t, 0, Infinity}, 
   WorkingPrecision -> 50, MaxRecursion -> 20];

Let ma be the MRB constant with that term:

ma = m + (2/3 - E^Pi)/(1/3 - c)/10^6;

Calculating more digits of 20/(E^Pi - Pi):

N[20/(E^Pi - Pi), 12]

gives

1.00004500307.

Calculating the new sum with ma instead of m:

N[2 - 100/(E^Pi/ma - E^Pi), 12]

gives

1.00004500308.

What about the second of the similar-looking approximated sums,

N[2 - 100/(E^Pi/x - E^Pi), 15]/N[20/(E^Pi - Pi), 15] vs.N[3 - 100/(E^Pi/x - E^Pi), 16] - N[20/(E^Pi - Pi), 16]?

So we have the new x, ma. Then

N[2 - 100/(E^Pi/ma - E^Pi), 15]/N[20/(E^Pi - Pi), 15]

gives

1.00000000001744.

While

N[3 - 100/(E^Pi/ma - E^Pi), 16] - N[20/(E^Pi - Pi), 16]

gives the exactly the same value of

1.000000000017440.

Holy corrected vision Batman!

POSTED BY: Marvin Ray Burns

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

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

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

In[63]:= 225897077238546^m - m

Out[63]= 496.99999999999999975304752932252481772179797865

In[62]:= 1668628852566227424415^m - m

Out[62]= 9700.9999999999999999994613109586919797992822178

In[61]:= 605975224495422946908^m - m

Out[61]= 8019.9999999999999999989515156294756517433387956

In[60]:= 3096774194444417292742^m - m

Out[60]= 10896.0000000000000000000000096284579090392932063

In[56]:= 69554400815329506140847^m - m

Out[56]= 19549.9999999999999999999999991932013520540825206

In[68]:= 470143509230719799597513239^m - m

Out[68]= 102479.000000000000000000000000002312496475978584

In[70]:= 902912955019451288364714851^m - m

Out[70]= 115844.999999999999999999999999998248770510754951

In[73]:= 2275854518412286318764672497^m - m

Out[73]= 137817.000000000000000000000000000064276966095482

In[146]:= 2610692005347922107262552615512^m - m

Out[146]= 517703.00000000000000000000000000000013473353420

In[120]:= 9917209087670224712258555601844^m - m

Out[120]= 665228.00000000000000000000000000000011062183643

In[149]:= 19891475641447607923182836942486^m - m

Out[149]= 758152.00000000000000000000000000000001559954712

In[152]:= 34600848595471336691446124576274^m - m

Out[152]= 841243.00000000000000000000000000000000146089062

In[157]:= 543136599664447978486581955093879^m - m

Out[157]= 1411134.0000000000000000000000000000000035813431

In[159]:= 748013345032523806560071259883046^m - m

Out[159]= 1498583.0000000000000000000000000000000031130944

In[162]:= 509030286753987571453322644036990^m - m

Out[162]= 1394045.9999999999999999999999999999999946679646


In[48]:= 952521560422188137227682543146686124^m - m

Out[48]=5740880.999999999999999999999999999999999890905129816474332198321490136628009367504752851478633240


In[26]:= 50355477632979244604729935214202210251^m - m

Out[26]=12097427.00000000000000000000000000000000000000293025439870097812782596113788024271834721860892874


In[27]:= 204559420776329588951078132857792732385^m - m

Out[27]=15741888.99999999999999999999999999999999999999988648448116819373537316944519114421631607853700001


In[46]:= 4074896822379126533656833098328699139141^m - m

Out[46]= 27614828.00000000000000000000000000000000000000001080626974885195966380280626150522220789167201350


In[8]:= 100148763332806310775465033613250050958363^m - m

Out[8]= 50392582.999999999999999999999999999999999999999998598093272973955371081598246


In[10]=  116388848574396158612596991763257135797979^m - m

Out[10]=51835516.000000000000000000000000000000000000000000564045501599584517036465406


In[12]:= 111821958790102917465216066365339190906247589^m - m

Out[12]= 188339125.99999999999999999999999999999999999999999999703503169989535000879619


In[33] := 8836529576862307317465438848849297054082798140^m - m

Out[33] = 42800817.00000000000000000000000000000000000000000000000321239755400298680819416095288742420653229


In[71] := 532482704820936890386684877802792716774739424328^m - m

Out[71] =924371800.999999999999999999999999999999999999999999999998143109316148796009581676875618489611792


In[21]:= 783358731736994512061663556662710815688853043638^m - m

Out[21]= 993899177.0000000000000000000000000000000000000000000000022361744841282020


In[24]:= 8175027604657819107163145989938052310049955219905^m - m

Out[24]= 1544126008.9999999999999999999999999999999999999999999999999786482891477\
944981


19779617801396329619089113017251584634275124610667^m - m
gives
1822929481.00000000000000000000000000000000000000000000000000187580971544991111083798248746369560.


130755944577487162248300532232643556078843337086375^m - m

gives 

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

(51 consecutive 9 s)

322841040854905412176386060015189492405068903997802^m - m

gives

3080353548.000000000000000000000000000000000000000000000000000019866002281287395703598786588650156

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

(52 consecutive 0 s)


310711937250443758724050271875240528207815041296728160^m - m

gives

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

(55 consecutive 9s)

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

(62 consecutive 9 s).

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

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

In[2]:= d=114705489440921816400568391832103;N[10539265076340778455746831348074621/(10d)+(1315939211433987901830906252006812 Sqrt[2]) / d+(2238154781652703157536445225769983 Sqrt[5]) / (2d)+(464968409472439567819541453580715 6^(1/6)) / d-(1917024616230569159116802658552184 Pi ) / d-m]

Out[2]= -9.93177*^-201

POSTED BY: Marvin Ray Burns

Well, I've tried 6,000,000 at least 5 times and am getting nowhere! I started a 5,555,555 digit computation on 19 Jun 2020 22 : 20 : 08, to break my bad luck spree: Here are my latest results:

enter image description here

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

POSTED BY: Marvin Ray Burns

While the 5,555,555 digit calculation is working, I thought I would mention my latest mini-project. I wanted to look at computing the MRB constant, (0.18785964...) through a generalized continued fraction for z^(1/z).

At Mathworld we see a suitable continued fraction here.

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

.

It looks like

enter image description here

. -

With only 10 terms, I was able to calculate 4 decimals of the constant, 0.1878, the equivalent of adding up to 299,999 terms by brute force!

N[1/2 - Sum[(-1)^x*
         {(2*(x - 1))/(ContinuedFractionK[
                    (x - 1)^2*(-(n^2*x^2 - 1)), 
                    (2*n + 1)*x*(x + 1), 
                    {n, 3}] + x^2 + 1) + 1}, 
       {x, 1, 10^1}]]

. -

That gives 0.1878368104323782.

See, N[Sum[(-1)^n (n^(1/n) - 1), {n, 1, 299999}]] gives 0.18783862276177388.

It looks like the following.

enter image description here

. -

POSTED BY: Marvin Ray Burns

(You guessed it!) my 5,555,555 digit computation died from another long term power outage. I need a household generator! If I get a generator, I could calculate up to10,000,000 digits!

P. S. Several times, I mentioned Crandall's first MRB constant Dirichlet's eta derivative formula: enter image description here.

I concluded with what I think is the fastest way of computing it in the message that starts out with " 4/22/2019". But there is something else I would like to test out: At https://www.sciencedirect.com/science/article/pii/S0022314X15001882 , there is the Adell-Lekuona scheme to quickly calculate the mth derivatives of eta of m. Stay tuned for what I find out!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Edit:

I got some meager results of calculating the nth derivatives of eta of n from the Adell-Lekuona scheme:

enter image description here

...

enter image description here enter image description here

First I define c and the nth derivative of eta sub 1 of n from the scheme:

c[t_, n_] := (-1.`30.)^(n + t)* Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1.`30.)^(n - l - j)*(Log[l + j + 1]/(l + j + 1))^t, {j, 0, n - l}], {l, 0,n}]; 

etad[t_] := (2/3)*
  NSum[c[t, n]/3^n, {n, 0, 20}, Method -> "AlternatingSigns", 
       WorkingPrecision -> 30]

Then I compare the results with the actual derivatives:

In[152]:= etad[2] - N[Derivative[n][DirichletEta][n] /. n -> 2, 30]

Out[152]= -5.6495702147568955843*10^-12

In[153]:= etad[3] - N[Derivative[n][DirichletEta][n] /. n -> 3, 30]

Out[153]= 3.4964879453028546174*10^-12

In[154]:= etad[4] - N[Derivative[n][DirichletEta][n] /. n -> 4, 30]

Out[154]= -1.19233015142032460531*10^-12

In[168]:= etad[10] - N[Derivative[n][DirichletEta][n] /. n -> 10, 30]

Out[168]= 3.859680615418530806797*10^-14

In[190]:= etad[100] - N[Derivative[n][DirichletEta][n] /. n -> 100, 30]

Out[190]= -1.8845740316090756479036*10^-51

I'm getting more digits as the value of n goes up..

EDIT (3 days later)

Here are more than 224 accurate digits of the MRB constant via only the Adell-Lekuona scheme in 44 min:

First, I calculated 240 digits that have been proven to be correct to well beyond 224 digits:

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

  Out[132]= \
  0.18785964246206712024851793405427323005590309490013878617200468408947\
  7231564660213703296654433107496903842345856258019061231370094759226630\
  4389293488961841208373366260816136027381263793734352832125527639621714\
  893217020762820621715167151756

Then I entered a line that computes the nth derivatives of eta of n:

            c[t_, n_] := (-1`240)^(n + t)*Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)* (N[Log[l + j + 1], 250]/(l + j + 1))^t, {j,  0, n - l}], {l, 0,  n}];
            etad[t_] := (2/3)*N[ Sum[c[t, n]/3^n, {n, 1, 500} ], 250]

Then I entered the program to compute the MRB constant from the derivatives:

        Timing[shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 120}, Method -> "WynnEpsilon",WorkingPrecision -> 240, NSumTerms -> 90]]

Here are the time it took and the digits calculated:

    {2656.11, \
    0.18785964246206712024851793405427323005590309490013878617200468408947\
    7231564660213703296654433107496903842345856258019061231370094759226630\
    4389293488961841208373366260816136027381263793734352832125527639621714\
    893217020762821}

Here those digits are proven to be correct to 224 digits:

  In[138]:= m - shot

  Out[138]= 0.*10^-224

Compare with my fastest 224 digit computation, 62.5 milliseconds:

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

            SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**
                N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, 
                cores - 1}, Method -> "EvaluationsPerKernel" -> 32]];
        ctab = ParallelTable[Table[c = b - c;
              ll = start + l - 2;
              b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
              c, {l, chunksize}], 
      Method -> "EvaluationsPerKernel" -> 16];
        s += ctab.(xvals - 1);
        start += chunksize;
        st = SessionTime[] - T0; kc = k*chunksize;
        ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
        If[kc > 1, 
          Print[kc, " iterations done in ", N[st, 4], " seconds.", 
            " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], 
            "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
      N[-s/d, pr]];
t2 = Timing[MRB1 = expM[prec];]; Print["Finished on ", 
  DateString[], ". Proccessor time was ", t2[[1]], " s."];
Print["Enter MRBtest2 to print ", Floor[Precision[MRBtest2]], 
   " digits"]; m3M - MRB1


During evaluation of In[72]:= Start time is Mon 7 Sep 2020 03:19:21.

During evaluation of In[72]:= Iterations required: 298

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

During evaluation of In[72]:= Will stop at 2048 iterations to ensure precision of around 226 decimal places.

During evaluation of In[72]:= Finished on Mon 7 Sep 2020 03:19:21. Processor time was 0.0625 s.

During evaluation of In[72]:= Enter MRBtest2 to print \[Infinity] digits

Out[78]= 0.*10^-224

That is 40,615 times faster. My use of the Adell-Lekuona scheme has a way to go.

P.S. I did a lot of research and found out that my use of the Adell-Lekuona scheme is no faster, for up to around half a hundred digits than the following "brute force" one. And I show where it is a great deal slower! The scheme's main advantage seems to be being able to compute more of a maximum of digits (like the above 224, which to me seems impossible to match with a PC and general math software).

In[45]:= m = 
 NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, WorkingPrecision -> 100,
   Method -> "AlternatingSigns"]; Timing[
 c1 = Limit[(-1)^n/n! Derivative[n][DirichletEta][x] /. n -> 1, 
   x -> 1];

 m + (c1 + 
    NSum[(-1)^n/n! Derivative[n][DirichletEta][n], {n, 2, 30}, 
     Method -> "WynnEpsilon", WorkingPrecision -> 100])]

Out[45]= {7.84375, -2.40588*10^-48}

vs scheme:

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

Out[1]=  0.\
1878596424620671202485179340542732300559030949001387861720046840894772\
3156466021370329665443217278

In[41]:=    c[t_, n_] := (-1`60)^(n + t)*

  Sum[Binomial[n, l]*Sum[Binomial[n - l, j]*(-1)^(n - l - j)*
                         (Log[l + j + 1]/(l + j + 1))^t, {j, 0, 
      n - l}], {l, 0, 
             n}]; etad[t_] := (2/3)*
            N[ Sum[c[t, n]/3^n, {n, 1, 90} ], 60]

In[42]:= Timing[
 shot = -NSum[(-1)^x etad[x]/x!, {x, 1, 30}, Method -> "WynnEpsilon", 
    WorkingPrecision -> 60, NSumTerms -> 60]]

Out[42]= {12.5781, \
0.187859642462067120248517934054273230055903094615556440737580}

In[43]:= m - shot

Out[43]= 2.84582345434425*10^-46
POSTED BY: Marvin Ray Burns

The Seventh attempt at Calculating 6,000,000 digits

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

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

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

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

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

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

POSTED BY: Marvin Ray Burns

I said, "would get back to you when I made some progress." Well here's what I did. 1 node of the MRB constant supercomputer is calculating 6 million digits using the same program used above. Another node is calculating 7,500,000 digits using an experimental, faster program, which digits I will round down to 7,000,000. The remaining node is calculating 5,500,000 digits using only Richard Crandall's original algorithm. If they all three agree to 5,500,000 digits, I will be certain that those digits are correct. And if the 6,000,000 are the same found in the rounded down 7,500,000, will be pretty-well satisfied that they are correct. And experience has taught me that the last one is probably correct to 7,000,000 or more.

The 5,500,000 digits computation using only Crandall's original method can be found here: https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nb .

The 6,000,000 digits computation using my method found in the previous message, here: https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nb

The 7,500,000 digits computation using the experimental, faster method, here: https://www.wolframcloud.com/obj/bmmmburns/Published/first2%207%20million%2011p3.nb .

The node tasked with the 7,500,000 digits computation using the experimental, faster method crashed, so I reassigned it 6,500,000 digits using my proven method.

It is now found here:

.

POSTED BY: Marvin Ray Burns

It's been a while since I checked in with you all, so here is an encouraging update! The 5,500,000 digits computation using only Crandall's original method can be found here:

https://www.wolframcloud.com/obj/bmmmburns/Published/5p5million.nb

The latest output is In[85]:= DateString[]

     5235200   iterations in  1.13741582450835*10^7 seconds.

     "Thu 4 Mar 2021 08:03:45"

      70.6928% done.

The 6,500,000 digits using my proven method.:

https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC26p5million.nb

The latest output is

 As of  Thu 4 Mar 2021 07:53:12 there were 4317184 iterations done in 9.2996*10^6 seconds. That is 0.46423 iterations/s. 50.05937% complete. It should take 214.983 days or 1.857*10^7s, and finish Sat 19 Jun 2021 16:14:58.

The 6,000,000 digits computation using my method found in the previous messages, here:

https://www.wolframcloud.com/obj/bmmmburns/Published/MRBSC2%206%20million%201st%20fourth.nb

The latest output is

As of  Thu 4 Mar 2021 08:47:02 there were 6662144 iterations done in 1.1599*10^7 seconds. That is 0.57435 iterations/s. 83.68922% complete. It should take 160.398 days or 1.386*10^7s, and finish Tue 30 Mar 2021 12:16:52.

P.S as of 04:00 am 1/2/2021, this discussion had 300,000 views!

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

POSTED BY: Marvin Ray Burns
Posted 1 year ago

Update on the 6,000,000 digit computation.

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

Latest output:

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

POSTED BY: Updating Name

I DECLARE VICTORY!

I computed 6,000,000 digits of the MRB constant, finishing on Tue 30 Mar 2021 22:02:49. The MRB constant supercomputer 2 said the following:

  Finished on Tue 30 Mar 2021 22:02:49. Processor and actual time were 5.28815859375*10^6 and 1.38935720536301*10^7 s. respectively

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

  0.*10^-5024993

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

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

Attachments:
POSTED BY: Marvin Ray Burns

Distribution of digits

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

enter image description here

Here is the distribution of digits within the first 5,000,000 decimal places (.187859,,,), "4" shows up a lot more than other digits, followed by "0," "8" and "6." enter image description here

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

3,000,000 digits share a similar distribution:

enter image description here

Over the first 2 and 1 million digits "4" was not so well represented. So, the heavy representation of "4" is shown to be a growing phenomenon from 2 million to 5 million digits. However, "1,2,and 5" still made a very poor showing: enter image description here

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

Attachments:
POSTED BY: Marvin Ray Burns

The MRB constant supercomputer 2 is still working on 6,500,000 and 5,500,000 digit computations. The latest output on the 6,500,000 digit computation is

As of  Sun 11 Apr 2021 18:04:26 there were 5810176 iterations done in 1.2619*10^7 seconds. That is 0.46041 iterations/s. 67.37117% complete. It should take 216.766 days or 1.873*10^7s, and finish Mon 21 Jun 2021 11:03:14.

The 5,500,000 is being done by a totally different method. Its latest output is

6686208  iterations in  1.46938392445428*^7 seconds.

90.27240044247787% done.

When they are complete we will know for a fact what 5,500,000 digits of the MRB constant are! If the 6,500,000 digit computation gives the same answer as the 6,000,000 digit computation, experience has taught us, there is no reason to doubt it will be right.

POSTED BY: Marvin Ray Burns

Probably the last update on the 5,500,000 digit computation:

Print[7211520/7405568*100., "% done."]

97.37970132743364% done.

When it is done, having the same first 5,500,000 digits found in the previous 6,000,000 digit computation by a totally different method, it will prove beyond any shadow of a doubt the 5,500,000 digits are correct.

Stay tuned!

POSTED 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

This reply was condensed and added to the first post.

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

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

 In[2]:= Needs["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]

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

Iterations required: 8622898

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

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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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

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

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

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

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

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

Here a recent update:

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

A few days later,

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

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

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

The MRB constant supercomputer just said,

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

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

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

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

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

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

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

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

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

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

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

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


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

...

Stay tuned, I will add the next several 6,500,000 digit computation updates in this reply.

Last update for 2021

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

2022 results

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

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

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

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

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

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

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

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

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

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

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

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

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

Probably my last update:

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

**

Less than 26 hours until completion!

**

POSTED BY: Marvin Ray Burns

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 rate of convergence of 3 major different forms of it. They are listed from slowest to fastest

POSTED BY: Marvin Ray Burns

Time for a quick memorial:

This discussion began sometime around 2/21/2013.

"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 7 months, this discussion has had as many visitors as it did in its first 7 years!

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

Programs to compute the integrated analog

The efficient programs

Wed 29 Jul 2015 11:40:10

From an initial accuracy of only 7 digits,

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

enter image description here

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

(See Primary Proof 3 in the first post.)

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

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

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

enter image description here

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

All digits at

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

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

enter image description here

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

Laurent series for the analog

I've not perfected the method, but here is how to compute the integrated analog of the MRB constant from series.

$f = (-1)^z (z^(1/z) - 1); MKB = 
 NIntegrate[$f, {z, 1, Infinity I}, WorkingPrecision -> 500]; 
Table[s[x_] = Series[$f, {z, n, x}] // Normal; 
  Timing[Table[
    MKB - Quiet[ 
      NIntegrate[s[x] /. z -> n, {n, 1, Infinity I}, 
       WorkingPrecision -> p, Method -> "Trapezoidal", 
       MaxRecursion -> Ceiling[Log2[p/2]]]], {p, 100, 100 x, 
     100}]], {x, 1, 10}] // TableForm

enter image description here

Table[Short[s[n]], {n, 1, 5}] // TableForm enter image description here

Attachments:
POSTED BY: Marvin Ray Burns

Moved below.

POSTED BY: Marvin Ray Burns

A reply a couple of places before this one has some "Programs to compute the integrated analog". Here is a recent discovery that could help in verifying the analog's digital expansions.

When f[x_] = E^(I Pi x) (1 - (1 + x)^(1/(1 + x))), the MRB constant is Sum[f[n],{n,0,Infinity}] and also, Sum[f[n],{n,1,Infinity}].

POSTED BY: Marvin Ray Burns

Removed.

POSTED BY: Marvin Ray Burns

The Laplace transform analogy to the 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 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

POSTED BY: Marvin Ray Burns

Moved below.

POSTED BY: Marvin Ray Burns

Real-World, and beyond, Applications

CMRB as a Growth Model

Its factor ![a][112] models the interest rate to multiply an investment k times in k periods, as well as "other growth and decay functions involving the more general expression ![(1+k)^n][113], as in Plot 1A," because ![enter image description here][114]

r=(k^(1/k)-1);Animate[ListPlot[l=Accumulate[Table[(r+1)^n,{k,100}]], PlotStyle->Red,PlotRange->{0,150},PlotLegends->{"\!\(\*UnderscriptBox[\(\[Sum]\), \(\)]\)(r+1\!\(\*SuperscriptBox[\()\), \(n\)]\)/.r->(\!\(\*SuperscriptBox[\(k\), \(1/k\)]\)-1)/.n->"n},AxesOrigin->{0,0}],{n,0,5}]

Plot 1A ![enter image description here][115]

The discrete rates looks like the following.

r = (k^(1/k) - 1); me = 
 Animate[ListPlot[l = Table[(r + 1)^n, {k, 100}], PlotStyle -> Red, 
   PlotLegends -> {"(r+1)^n/.r->\!\(\*SuperscriptBox[\(k\), \
\(1/k\)]\)=1/.n->", n}, AxesOrigin -> {0, 0}, 
   PlotRange -> {0, 7}], {n, 1, 5}]

![enter image description here][116]

That factor ![enter image description here][117] models not only discretely compounded rates but continuous too, ie ![Pt=p0e^rt.][118]

By entering

Solve[P*E^(r*t) == P*(t^(1/t) - 1), r] 

we see, for ![Pt=p0e^rt,][119] ![t>e][120]

gives an effect of continuous decay of ![enter image description here][121] Here Q1 means the first Quarter form 0 to -1.

The alternating sum of the principal of those continuous rates, i.e. P=(-1)t er t is the MRB constant (CMRB): ![enter image description here][122]

In[647]:= NSum[(-1)^t ( E^(r*t)) /. r -> Log[-1 + t^(1/t)]/t, {t, 1, 
  Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 30]

Out[647]= 0.18785964246206712024857897184

Its integral (MKB) is an analog to CMRB : ![enter image description here][123]

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

   Out[1]= 0.0707760393115288035395280218303 - 
    0.6840003894379321291827444599927 I

So, integrating P yields about 1/2 greater of a total than summing:

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

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

In[667]:= MKB - CMRB

Out[667]= 0.49979272646562724956073343752

Next:

CMRB from Geometric Series and Power Series

The MRB constant: ![enter image description here][124] is closely related to geometric series: ![enter image description here][125]

The inverse function of the "term" of the MRB constant, i.e. x^(1/x) within a certain domain is solved for in [this link,][126]

![enter image description here][127]

...

![enter image description here][128]

Now we have the following for the orientated area, from 0 to 1, between the graph of that term and the axis.

![enter image description here][129]

In[344]:= f[x_] = x^(1/x);

In[346]:= CMRB = 
 NSum[(-1)^x (f[x] - 1), {x, 1, Infinity}, WorkingPrecision -> 20]

Out[346]= 0.18785964246207

In[350]:= (10 (CMRB + 3))/(3 (3 CMRB - 17)) - 
 NIntegrate[g = -x /. Solve[y == f[x], x], {y, 0, 1}, 
  WorkingPrecision -> 20]

Out[350]= {1.5605*10^-11}

Consider the following about a slight generalization of that term.

![enter image description here][130]

CMRB can be written in geometric series form:

CMRB= ![enter image description here][131]

In[240]:= N[Quiet[(Sum[q^k, {x, 1, Infinity}] /. 
          k -> Log[-E^(I*Pi*x) + E^(x*(I*Pi + Log[x]/x^2))]/Log[q]) - 
       Sum[E^(I*Pi*x)*(-1 + x^(1/x)), {x, 1, Infinity}]]]

Out[240]= -4.163336342344337*^-16

Why would we express CMRB so? I'm not entirely sure, but we do have the following interestingly intricate graphs that go towards the value of the MRB constant and the MRB constant-1 as the input gets large. ![enter image description here][132] ![enter image description here][133] ![enter image description here][134] ![enter image description here][135]

![enter image description here][136] ![enter image description here][137]

see notebook [here.][138]


Next

The Geometry of the MRB constant


In 1837 Pierre Wantzel proved that an nth root of a given length cannot be constructed if n is not a power of 2 (as mentioned [here][139] in Wikipedia). However, the following is a little different.

For ![,][140] on November 21, 2010, I coined a multiversal [analog][141] to, [Minkowski space][142] that plots their values from constructions arising from a peculiar non-euclidean geometry, below, and fully in [this vixra draft][143].

As in Diagram 2, we give each n-cube a hyperbolic volume (content) equal to its dimension,![enter image description here][144] Geometrically, as in Diagram3, on the y,z-plane line up an edge of each n-cube. The numeric values displayed in the diagram are the partial sums of S[x_] = Sum[(-1)^n*n^(1/n), {n, 1, 2*u}] where u is an positive integer. Then M is the MRB constant.

![enter image description here][145]

Join[ Table[N[S[x]], {u, 1, 4}], {"..."}, {NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity}]}]

Out[421]= {0.414214, 0.386178, 0.354454, 0.330824, "...", 0.18786}


Here are views of some regions of the plot of a definite integral equal to CMRB..

![enter image description here][146]

In[66]:= Csch[Pi t] Im[(1 + I t)^(1/(1 + I t))]

Out[66]= Csch[[Pi] t] Im[(1 + I t)^(1/(1 + I t))]

In[67]:= f[t_] = Csch[Pi t] Im[(1 + I t)^(1/(1 + I t))]

Out[67]= Csch[[Pi] t] Im[(1 + I t)^(1/(1 + I t))]

ReImPlot[Im[(1 + I t)^(1/(1 + I t))], {t, 0, 1}, PlotStyle -> Blue, 
 PlotLabels -> {Placed[(1 + I t)^(1/(1 + I t)), Above]}]

![enter image description here][147]

ReImPlot[Im[(1 + I t)^(1/(1 + I t))], {t, 0, 5}, PlotStyle -> Blue, 
 PlotLabels -> {Placed[(1 + I t)^(1/(1 + I t)), Above]}]

![enter image description here][148]

Show[ReImPlot[Csch[\[Pi] t], {t, 0, 1}, PlotStyle -> Yellow, 
  PlotLabels -> "Expressions"]]

![enter image description here][149]

Show[ReImPlot[Csch[\[Pi] t], {t, 0, 5}, PlotStyle -> Yellow, 
  PlotLabels -> "Expressions"]]

![enter image description here][150]

ReImPlot[f[t], {t, 0, 1}, 
 PlotLabel -> NIntegrate[f[t], {t, 0, 1}, WorkingPrecision -> 20], 
 PlotStyle -> Green, PlotLabels -> "Expressions"]

![enter image description here][151]

ReImPlot[f[t], {t, 0, 5}, 
 PlotLabel -> NIntegrate[f[t], {t, 0, 5}, WorkingPrecision -> 20], 
 PlotStyle -> Green, PlotLabels -> "Expressions"]

![enter image description here][152]

Next







MeijerG Representation

From its integrated analog, I found a [MeijerG][153] representation for CMRB.

The search for it began with the following:

On 10/10/2021, I found the following proper definite integral that leads to almost identical proper integrals from 0 to 1 for CMRB and its integrated analog.

![m vs m2 0 to 1][154]

See [notebook in this link][155].

Here is a [MeijerG][156] function for the integrated analog. See [(proof)][157] of discovery.

![enter image description here][158]

f(n)=![enter image description here][159].

`

In[135]:=f[n_]:=MeijerG[{{},Table[1,{n+1}]},{Prepend[Table[0,n+1],-n+1],{}},-\[ImaginaryI]\[Pi]];`
       In[337]:=M2=NIntegrate[E^(I Pi x)(SuperscriptBox["x", FractionBox["1", "x"]]-1), 
  {x,1,Infinity I},WorkingPrecision->100]

Out[337]=0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723821-0.04738061707035078610720940650260367857315289969317363933196100090256586758807049779050462314770913485 \[ImaginaryI]

![enter image description here][160]

I wonder if there is one for the MRB constant sum (CMRB)?

According to "Primary Proof 1" and "Primary Proof 3" shown below along with the section prefixed by the phrase "So far I came up with," it can be proven that for G being the Wolfram MeijerG function

and f(n)=![enter image description here][161], and ![enter image description here][162]

g[x_] = (-1)^x (1 - (x + 1)^(1/(x + 1)));

In[52]:= (1/2)*
 NIntegrate[(g[-t] - g[t])/(Sin[Pi*t]*Cos[Pi*t]*I + Sin[Pi*t]^2), {t, 
   0, I*Infinity}, WorkingPrecision -> 100, 
     Method -> "GlobalAdaptive"]

Out[52]= 0.\
1170836031505383167089899122239912286901483986967757585888318959258587\
7430027817712246477316693025869 + 
 0.0473806170703507861072094065026036785731528996931736393319610009025\
6586758807049779050462314770913485 I



In[57]:= Re[
 NIntegrate[ 
  g[-t]/(Sin[Pi*t]*Cos[Pi*t]*I + Sin[Pi*t]^2), {t, 0, I*Infinity}, 
  WorkingPrecision -> 100, 
     Method -> "GlobalAdaptive"]]

Out[57]= 0.\
1878596424620671202485179340542732300559030949001387861720046840894772\
315646602137032966544331074969

The Laplace transform analogy to the 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 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



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][163]

=![enter image description here][164]

=![enter image description here][165]

=![enter image description here][166]

=![enter image description here][167]

=![enter image description here][168]

So, using induction, we have. ![enter image description here][169]

![enter image description here][170]

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][171]

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][172]

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

Expanding the E^log term gives

![enter image description here][174]

which is ![enter image description here][175],

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


2/21/2022

Directly from the formula of 12/29/2021 below, ![enter image description here][177] 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][178]

Expanding the exponents,

![enter image description here][179] This can be generalized to ![(x+log/][180]

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

CMRB= ![enter image description here][181]

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][182]

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[
       Im[(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][183], which defines the "integrated analog of CMRB" (MKB) described by Richard Mathar in [https://arxiv.org/abs/0912.3844][184]. (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][185] ![enter image description here][186].

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][187] ![enter image description here][188]

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][189]

[here,][190] and ![enter image description here][191] 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][192] 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][193]

You can see it worked [ in this link here][194].

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

back to mind, we joyfully find,

![CMRB n and 1][196]

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][197]

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

![CMRB integers 2][198]

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][199]



On 9/5/2021

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

![strange][200]

See proof [in this link here][201].



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

I added a new MRB constant integral.

![CMRB][202] ![=][203] ![integral to sum][204]

We see many more integrals for CMRB.

We can expand ![1/x][205] into the following.

![xx = 25.656654035][206]

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][207]

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

Another set follows.

let x = 1 and

along with the following {approximations}

{u = 2.451894470180356539050514},

{u = 1.333754341654332447320456} or

$ u = \infty $

then

![enter image description here][208]

See [this notebook from the wolfram cloud][209] for justification.



2020 and before:

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

CMRB =![enter image description here][210]

Furthermore, as ![enter image description here][211],

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



In the light of the parts above, where

CMRB

= ![k^(1/k)-1][216]

= ![eta'(k)][217]

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

![eta *z^k][221]






Primary Proof 1

CMRB=![enter image description here][222], based on

CMRB ![eta equals][223] ![enter image description here][224]

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

![Dark Marthorp's proof][225]



Primary Proof 2

![eta sums][226] 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![(][227]considering the conditionally convergent sum,![enter image description here][228]![)][229] below that. Then the right half is a Taylor expansion of eta(s) around s = 0.

![n^(1/n)-1][230]

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

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][232]), 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][233], culminating with the Fubini theorem which is essentially the manipulation Helms is using.)"

![argument 1][234] ![argument 2][235]



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][236]

Which is the same as

![enter image description here][237] 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][238] .

![Iimofg->1][239]

![Cauchy's Integral Theorem][240]

![Lim surface h gamma r=0][241]

![Lim surface h beta r=0][242]

![limit to 2n-1][243]

![limit to 2n-][244]

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

![left][245]![right][246]

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

![enter image description here][248]





I wondered about the relationship between CMRB and its integrated analog and asked the following. ![enter image description here][249] 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

POSTED BY: Marvin Ray Burns

July 9, 2022

Are is a table of several of my speed records from my fastest computers. First a caveat, there is a discrepancy in my timings in the first of the following 2 tables: The timings at and before " 3.2 GH 6core, 1666 MH RAM " were absolute timings. However, it was getting too hard to commit modern computers to just the one task of computing digits -- they are doing too many other things. So, I started recording computation time from the Timing command. table

The new 16-core computer's computations with verification are documented in this notebook. Although I'm not making any large number of digits computations, I'm still working on speed records:

However, all the following timings are absolute! From the first post,

01/08/2019

Here is an update of 100k digits (in seconds):

enter image description here

Notice, I broke the 1,000-second mark!!!!!

4th of July, 2022

I did it in 861 seconds of absolute time! enter image description here with the full power of the MRB constant supercomputer 3 (MRBSC 3).

See notebook.

7th of July, 2022

I did it in 691 seconds of absolute time!

enter image description here

See notebook.

30th of July, 2022

I did it in 682 seconds of absolute time!

enter image description here See notebook.

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

I'm getting fast at computing a potential 7 million digits of CMRB. See my latest attempt, where I had a crash. I'll try this again soon!

I'm off to the best start of 7,000,000 digits yet! The short program used above uses too much RAM. On the other hand, the code below uses less memory and the run below is maximized for core number efficiency, considering my network speed, for the 7,000,000 digits. Let's see if it finishes!

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

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

Start time is Thu 25 Aug 2022 19:27:24.

Iterations required: 9286198

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

Will stop at 9287680 iterations to ensure precsion of around 7034999 decimal places.



As of  Thu 25 Aug 2022 20:20:52 there were 2048 iterations done in 3208.0 seconds. That is 0.63841 iterations/s. 0.02205072% complete. It should take 168.354 days or 1.455*10^7s, and finish Fri 10 Feb 2023 03:57:26.



As of  Thu 25 Aug 2022 20:48:47 there were 4096 iterations done in 4883.5 seconds. That is 0.83874 iterations/s. 0.04410143% complete. It should take 128.144 days or 1.107*10^7s, and finish Sat 31 Dec 2022 22:54:30.



As of  Thu 25 Aug 2022 21:16:46 there were 6144 iterations done in 6562.7 seconds. That is 0.93620 iterations/s. 0.06615215% complete. It should take 114.804 days or 9.919*10^6s, and finish Sun 18 Dec 2022 14:44:41.



As of  Thu 25 Aug 2022 21:45:01 there were 8192 iterations done in 8257.1 seconds. That is 0.99211 iterations/s. 0.08820287% complete. It should take 108.334 days or 9.360*10^6s, and finish Mon 12 Dec 2022 03:28:00.



As of  Thu 25 Aug 2022 22:13:27 there were 10240 iterations done in 9963.0 seconds. That is 1.0278 iterations/s. 0.1102536% complete. It should take 104.571 days or 9.035*10^6s, and finish Thu 8 Dec 2022 09:10:06.



As of  Thu 25 Aug 2022 22:41:47 there were 12288 iterations done in 11663. seconds. That is 1.0536 iterations/s. 0.1323043% complete. It should take 102.016 days or 8.814*10^6s, and finish Mon 5 Dec 2022 19:50:31.



As of  Thu 25 Aug 2022 23:10:42 there were 14336 iterations done in 13398. seconds. That is 1.0700 iterations/s. 0.1543550% complete. It should take 100.447 days or 8.679*10^6s, and finish Sun 4 Dec 2022 06:10:31.



As of  Thu 25 Aug 2022 23:39:06 there were 16384 iterations done in 15102. seconds. That is 1.0849 iterations/s. 0.1764057% complete. It should take 99.0722 days or 8.560*10^6s, and finish Fri 2 Dec 2022 21:11:24.



As of  Fri 26 Aug 2022 00:07:52 there were 18432 iterations done in 16829. seconds. That is 1.0953 iterations/s. 0.1984564% complete. It should take 98.1296 days or 8.478*10^6s, and finish Thu 1 Dec 2022 22:34:01.



As of  Fri 26 Aug 2022 00:36:29 there were 20480 iterations done in 18545. seconds. That is 1.1043 iterations/s. 0.2205072% complete. It should take 97.3255 days or 8.409*10^6s, and finish Thu 1 Dec 2022 03:16:05.



As of  Fri 26 Aug 2022 01:05:23 there were 22528 iterations done in 20279. seconds. That is 1.1109 iterations/s. 0.2425579% complete. It should take 96.7496 days or 8.359*10^6s, and finish Wed 30 Nov 2022 13:26:49.



As of  Fri 26 Aug 2022 01:33:57 there were 24576 iterations done in 21993. seconds. That is 1.1174 iterations/s. 0.2646086% complete. It should take 96.1826 days or 8.310*10^6s, and finish Tue 29 Nov 2022 23:50:17.



As of  Fri 26 Aug 2022 02:02:48 there were 26624 iterations done in 23725. seconds. That is 1.1222 iterations/s. 0.2866593% complete. It should take 95.7749 days or 8.275*10^6s, and finish Tue 29 Nov 2022 14:03:18.



As of  Fri 26 Aug 2022 02:31:38 there were 28672 iterations done in 25454. seconds. That is 1.1264 iterations/s. 0.3087100% complete. It should take 95.4177 days or 8.244*10^6s, and finish Tue 29 Nov 2022 05:28:53.



As of  Fri 26 Aug 2022 03:01:12 there were 30720 iterations done in 27229. seconds. That is 1.1282 iterations/s. 0.3307607% complete. It should take 95.2642 days or 8.231*10^6s, and finish Tue 29 Nov 2022 01:47:49.



As of  Fri 26 Aug 2022 03:30:01 there were 32768 iterations done in 28957. seconds. That is 1.1316 iterations/s. 0.3528115% complete. It should take 94.9801 days or 8.206*10^6s, and finish Mon 28 Nov 2022 18:58:43.



As of  Fri 26 Aug 2022 03:59:00 there were 34816 iterations done in 30696. seconds. That is 1.1342 iterations/s. 0.3748622% complete. It should take 94.7606 days or 8.187*10^6s, and finish Mon 28 Nov 2022 13:42:37.



As of  Fri 26 Aug 2022 04:27:50 there were 36864 iterations done in 32426. seconds. That is 1.1369 iterations/s. 0.3969129% complete. It should take 94.5398 days or 8.168*10^6s, and finish Mon 28 Nov 2022 08:24:44.

Here is the latest report from the MRB constant supercomputer 3:

As of  Mon 29 Aug 2022 03:23:37 there were 329728 iterations done in 2.8777*10^5 seconds. That is 1.1458 iterations/s. 3.550165% complete. It should take 93.8034 days or 8.105*10^6s, and finish Sun 27 Nov 2022 14:44:18.

Then here:

As of  Thu 1 Sep 2022 21:08:43 there were 690176 iterations done in 6.1088*10^5 seconds. That is 1.1298 iterations/s. 7.431092% complete. It should take 95.1306 days or 8.219*10^6s, and finish Mon 28 Nov 2022 22:35:26.

Here:

As of  Sun 4 Sep 2022 19:15:45 there were 968704 iterations done in 8.6330*10^5 seconds. That is 1.1221 iterations/s. 10.42999% complete. It should take 95.7845 days or 8.276*10^6s, and finish Tue 29 Nov 2022 14:17:08.
POSTED BY: Marvin Ray Burns

At Stackexchange

Concerning CMRB=enter image description here=enter image description here,

I asked the following.

For some insight, I looked at comments by @Brevan Ellefsen, but still wonder if this integral can be expressed more elementarily than just calling it $ C_{MRB},$ which is short for the MRB constant which I first described as a sum at the end of the last millennium. There is no known closed-form expression of the MRB constant. With as slow as the series is to converge and as hard the integral is to calculate, a finite number of standard operations for the constant would be just glorious! Here is a summary of nearly a quarter century of evaluating it.

@Dark Malthorp had the insight to prove my suspicion as shown: "

enter image description here "

Is it possible to use a residue calculation to find a closed form for $$ C{MRB} = \int0^\infty \frac{\Im(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}dt? $$

I'm not sure if I'm on the right track, but $\frac{(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}$ having a pole at $0,$ can we consider the possibility of evaluating $$ 2C_{MRB} = \int_{-\infty}^\infty \frac{\Im(1+it)^{\frac1{1+it}}}{\sinh(\pi t)}dt? $$ I found out Mathematica gives the following.


In[70]:= Limit[Im[(1 + I t)^(1/(1 + I t)) Csch[\[Pi] t]], t -> 0]

Out[70]= 1/\[Pi]

In[181]:= Residue[(1 + I t)^((1/(1 + I t))) /Sinh[\[Pi] t], {t, 0}]

Out[181]= 1/\[Pi]

In[236]:= NIntegrate[
 Im[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]], {t, 0, Infinity}]

Out[236]= 0.18786

In[237]:= 1/2 - 1./Pi

Out[237]= 0.18169

This line of reasoning gives a nice set of approximations for CMRB, but nothing exact.

In[527]:= CMRB=NSum[(-1)^n (n^(1/n)-1),

{n,1,Infinity},WorkingPrecision->30,Method->"AlternatingSigns"]

Out[527]= 0.18785964246206712024857897184

Let p be the following partial approximation

In[544]:= p=((1/2-1/\[Pi])+1/(2 \[Pi]-1));

In[545]:= CMRB - 1/2 p

Out[545]= 0.00237470999999980600500193334

In[546]:= (-279/(485 \[Pi]) + p) - CMRB

Out[546]= -7.2407186775943961640*10^-10

In[547]:= (237471/50000000 + p)/2 - CMRB

Out[547]= 1.9399499806666*10^-16

In[548]:= (Pi^2 Sqrt[4187/10993830] + p)/3 - CMRB

Out[548]= 3.1221252470091*10^-16

enter image description here


A different line of reasoning follows, but its analysis, or how to improve its approximation (or even to determine whether that approximation is fully related to it) is beyond my power.

enter image description here

Here is a little more detail showing some symmetry, but I don't see anything exactly equaling CMRB here. enter image description here enter image description here In

CMRB/2 + NIntegrate[
  E/Pi t - Im[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]]/
    Re[(1 + I t)^(1/(1 + I t))/Sinh[Pi t]], {t, 0, a}, 
  WorkingPrecision -> 20] - (3078 p)/(7769 p + 3850)

Out[827]= 1.714*10^-19

POSTED BY: Marvin Ray Burns

Here is an answer to the previous question.

While mathematicians try to crack this nut, here's a physicist's point of view. I will focus on how to calculate this integral, keeping things as simple as possible, probably approximately.

The imaginary part of $(1+it)^{\frac{1}{1+it}}$:

$$f(t)=(1+t^2)^{\frac{1}{2(1+t^2)}}e^{\frac{t\arctan t}{1+t^2}}\sin\left [\frac{\arctan t}{1+t^2}-\frac{t\ln(1+t^2)}{2(1+t^2)} \right ]$$

Such a gem divided by $\sinh(\pi t)$ needs to be integrated from zero to infinity in so-called closed form.

For a physicist, this is a hopeless case. But...

Some of the first terms of Taylor's expansion of $f(t)$:

$$t-\frac{t^3}{2}-\frac{3t^5}{4}+...$$

Indeed, this expansion diverges for $1<t$

Nevertheless, we divide the first two terms of the expansion by $\sinh(\pi t)$, integrate from zero to infinity, and use well-known results:

$$\int_0^\infty \frac{t}{\sinh(\pi t)}dt=\frac{1}{4}$$

$$\int_0^\infty \frac{t^3}{\sinh(\pi t)}dt=\frac{1}{8}$$

Result:

$$\frac{1}{4}-\frac{1}{16}=\frac{3}{16}$$

The absolute deviation from the exact value is about $0.0004$

This is an example of that how we can use diverging series to compute values. It is only important to guess where to truncate the series.

POSTED BY: Marvin Ray Burns

enter image description here

The MRB constant (CMRB) can be compared to the constant $\pi$ in terms of how normal of a number it is: here.

Example, where CMRB has an normality number of 0, perfectly normal in base 5 for 50 digits.

enter image description here

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