The MRB constant: ALL ABOARD!
POSTED BY: Marvin Ray Burns.
Map:
- First, world records of the maximum number of digits of C_{MRB}
computations by date.
- Formal identities and theory for C_{MRB}. (My most recently discovered identities are summarized first and they use some advanced operations.)
- 3 primary proofs for all the listed C_{MRB} formal identities that are not proven already.
Some hints for anyone serious about breaking my record.
- Speed records,
- a program Richard Crandall wrote to check his code for the computing record number of digits
- and a conversation about whether Mathematica uses the same algorithm for computing C_{MRB} by a couple of different methods.
For a few replies, we compute C_{MRB} from Crandall's eta derivative formulas and see records there.
Three replies about "NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!" and the computation is now complete.
5,000,000 digit calculation. (Very fast!)
- The MRB supercomputer. (faster than some computers with dual platinum Xeon processors) It was used for the 5,000,000 digit calculation.
The 6 million digit computation of C_{MRB}. (put on hold, but taken up again later)
C_{MRB} sum via an integral, which certifies the accuracy of C_{MRB} calculations.
The task of calculating 6,000,000 (6 million) digits of C_{MRB} (for the fourth, fifth time, sixth, seventh time!) (will finish Thu 25 Feb 2021 06:48:06). merry christmass
- Look for closed forms and find nontrivial, arbitrarily close approximations of C_{MRB}.
Latest updates on the MRB constant supercomputer 2 (with a GIF of it) and how I'm using it to break new records -- up to 6,500,000 digits which failed when 70.7% complete -- are in a few replies.
On my 8th try I finally report that I successfully computed 6,000,000 digits of C_{MRB} !
Proving the accuracy of my computations.
For a few replies, find a few more formulas for C_{MRB,}.
Take up the challenge of computing 6,500,000 digits for the second time.
While we patiently wait for the 6,500,000 digits, find rapidly converging series for C_{MRB,}.
C_{MRB} is defined at http://mathworld.wolfram.com/MRBConstant.html.
SEE ALSO:
Glaisher-Kinkelin Constant, Power Tower, Steiner's Problem
REFERENCES:
Burns, M. R. "An Alternating Series Involving n^(th) Roots." Unpublished note, 1999.
Burns, M. R. "Try to Beat These MRB Constant Records!" http://community.wolfram.com/groups/-/m/t/366628.
Crandall, R. E. "Unified Algorithms for Polylogarithm, L-Series, and Zeta Variants." 2012a.
http://www.marvinrayburns.com/UniversalTOC25.pdf.
Crandall, R. E. "The MRB Constant." §7.5 in Algorithmic Reflections: Selected Works. PSI Press, pp. 28-29, 2012b.
Finch, S. R. Mathematical Constants. Cambridge, England: Cambridge University Press, p. 450, 2003.
Plouffe, S. "MRB Constant." http://pi.lacim.uqam.ca/piDATA/mrburns.txt.
Sloane, N. J. A. Sequences A037077 in "The On-Line Encyclopedia of Integer Sequences."
Referenced on Wolfram|Alpha: MRB Constant
CITE THIS AS:
Weisstein, Eric W. "MRB Constant." From MathWorld--A Wolfram Web Resource. https://mathworld.wolfram.com/MRBConstant.html
As with any scientific paper, this post contains only reproducible results with methods. These records represent the advancement of consumer-level computers and clever programming over the past 20 years. I see others breaking these records, even after I die!
Here are some record computations. If you know of any others let me know.
On or about Dec 31, 1998, I computed 1 digit of the (additive inverse of ) C_{MRB} with my TI-92s, by adding 1-sqrt(2)+3^(1/3)-4^(1/4)+... as far as I could. That first digit, by the way, is just 0. Then by using the sum feature, in approximate mode, to compute
$\sum _{n=1}^{1000 } (-1)^n \left(n^{1/n}\right),$
I computed the first correct decimal of
$\text{CMRB}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right)$ i.e. (.1). It gave (.1_91323989714) which is close to what Mathematica gives for summing to only an upper limit of 1000.
On Jan 11, 1999, I computed 4 decimals(.1878) of C_{MRB} with the Inverse Symbolic Calculator, with the command evalf( 0.1879019633921476926565342538468+sum((-1)^n* (n^(1/n)-1),n=140001..150000)); where 0.1879019633921476926565342538468 was the running total of t=sum((-1)^n* (n^(1/n)-1),n=1..10000), then t= t+the sum from (10001.. 20000), then t=t+the sum from (20001..30000) ... up to t=t+the sum from (130001..140000).
In Jan of 1999, I computed 5 correct decimals (rounded to .18786)of C_{MRB} using Mathcad 3.1 on a 50 MHz 80486 IBM 486 personal computer operating on Windows 95.
Shortly afterward I tried to compute 9 digits of C_{MRB} using Mathcad 7 professional on the Pentium II mentioned below, by summing (-1)^x x^(1/x) for x=1 to 10,000,000, 20,000,000, and a many more, then linearly approximating the sum to a what a few billion terms would have given.
On Jan 23, 1999, I computed 500 digits of C_{MRB} with an online tool called Sigma. Remarkably the sum in 4. was correct to 6 of the 9 decimal places! See
http://marvinrayburns.com/OriginalMRBPost.html
if you can read the printed and scanned copy there.
In September of 1999, I computed the first 5,000 digits of C_{MRB} on a 350 MHz Pentium II with 64 Mb of RAM using the simple PARI commands \p 5000;sumalt(n=1,((-1)^n*(n^(1/n)-1))), after allocating enough memory.
On June 10-11, 2003 over a period, of 10 hours, on a 450 MHz P3 with an available 512 MB RAM, I computed 6,995 accurate digits of C_{MRB}.
Using a Sony Vaio P4 2.66 GHz laptop computer with 960 MB of available RAM, at 2:04 PM 3/25/2004, I finished computing 8000 digits of C_{MRB}.
On March 01, 2006, with a 3 GHz PD with 2 GB RAM available, I computed the first 11,000 digits of C_{MRB}.
On Nov 24, 2006, I computed 40, 000 digits of C_{MRB} in 33 hours and 26 min via my program written in Mathematica 5.2. The computation was run on a 32-bit Windows 3 GHz PD desktop computer using 3.25 GB of Ram.
The program was something like this:
Block[{a, b = -1, c = -1 - d, d = (3 + Sqrt[8])^n,
n = 131 Ceiling[40000/100], s = 0}, a[0] = 1;
d = (d + 1/d)/2; For[m = 1, m < n, a[m] = (1 + m)^(1/(1 + m)); m++];
For[k = 0, k < n, c = b - c;
b = b (k + n) (k - n)/((k + 1/2) (k + 1)); s = s + c*a[k]; k++];
N[1/2 - s/d, 40000]]
Finishing on July 29, 2007, at 11:57 PM EST, I computed 60,000 digits of C_{MRB}. Computed in 50.51 hours on a 2.6 GHz AMD Athlon with 64 bit Windows XP. Max memory used was 4.0 GB of RAM.
Finishing on Aug 3, 2007, at 12:40 AM EST, I computed 65,000 digits of C_{MRB}. Computed in only 50.50 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 5.0 GB of RAM.
Finishing on Aug 12, 2007, at 8:00 PM EST, I computed 100,000 digits of C_{MRB}. They were computed in 170 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.
Finishing on Sep 23, 2007, at 11:00 AM EST, I computed 150,000 digits of C_{MRB}. They were computed in 330 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 22 GB of RAM. The typical daily record of memory used was 17 GB of RAM.
Finishing on March 16, 2008, at 3:00 PM EST, I computed 200,000 digits of C_{MRB} using Mathematica 5.2. They were computed in 845 hours on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 47 GB of RAM. The typical daily record of memory used was 28 GB of RAM.
Washed away by Hurricane Ike -- on September 13, 2008 sometime between 2:00 PM - 8:00 PM EST an almost complete computation of 300,000 digits of C_{MRB} was destroyed. Computed for a long 4015. Hours (23.899 weeks or 1.4454*10^7 seconds) on a 2.66 GHz Core 2 Duo using 64 bit Windows XP. Max memory used was 91 GB of RAM. The Mathematica 6.0 code used follows:
Block[{$MaxExtraPrecision = 300000 + 8, a, b = -1, c = -1 - d,
d = (3 + Sqrt[8])^n, n = 131 Ceiling[300000/100], s = 0}, a[0] = 1;
d = (d + 1/d)/2; For[m = 1, m < n, a[m] = (1 + m)^(1/(1 + m)); m++];
For[k = 0, k < n, c = b - c;
b = b (k + n) (k - n)/((k + 1/2) (k + 1)); s = s + c*a[k]; k++];
N[1/2 - s/d, 300000]]
On September 18, 2008, computation of 225,000 digits of C_{MRB} was started with a 2.66 GHz Core 2 Duo using 64 bit Windows XP. It was completed in 1072 hours. Memory usage is recorded in the attachment pt 225000.xls, near the bottom of this post.
250,000 digits were attempted but failed to be completed to a serious internal error that restarted the machine. The error occurred sometime on December 24, 2008, between 9:00 AM and 9:00 PM. The computation began on November 16, 2008, at 10:03 PM EST. Like the 300,000 digit computation, this one was almost complete when it failed. The Max memory used was 60.5 GB.
On Jan 29, 2009, 1:26:19 pm (UTC-0500) EST, I finished computing 250,000 digits of C_{MRB}. with a multiple-step Mathematica command running on a dedicated 64 bit XP using 4 GB DDR2 RAM onboard and 36 GB virtual. The computation took only 333.102 hours. The digits are at http://marvinrayburns.com/250KMRB.txt. The computation is completely documented in the attached 250000.PD at bottom of this post.
On Sun 28 Mar 2010 21:44:50 (UTC-0500) EST, I started a computation of 300000 digits of C_{MRB} using an i7 with 8.0 GB of DDR3 RAM onboard, but it failed due to hardware problems.
I computed 299,998 Digits of C_{MRB}. The computation began Fri 13 Aug 2010 10:16:20 pm EDT and ended 2.23199*10^6 seconds later |
Wednesday, September 8, 2010. I used Mathematica 6.0 for Microsoft
Windows (64-bit) (June 19, 2007) That is an average of 7.44 seconds per digit. I used my Dell Studio XPS 8100 i7 860 @ 2.80 GHz with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929
GB virtual Ram.
I computed exactly 300,000 digits to the right of the decimal point
of C_{MRB} from Sat 8 Oct 2011 23:50:40 to Sat 5 Nov 2011
19:53:42 (2.405*10^6 seconds later). This run was 0.5766 seconds per digit slower than the
299,998 digit computation even though it used 16 GB physical DDR3 RAM on the same machine. The working precision and accuracy goal
combination were maximized for exactly 300,000 digits, and the result was automatically saved as a file instead of just being displayed on the front end. Windows reserved a total of 63 GB of working memory of which 52 GB were recorded being used. The 300,000 digits came from the Mathematica 7.0 command
Quit; DateString[]
digits = 300000; str = OpenWrite[]; SetOptions[str,
PageWidth -> 1000]; time = SessionTime[]; Write[str,
NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]},
WorkingPrecision -> digits + 3, AccuracyGoal -> digits,
Method -> "AlternatingSigns"]]; timeused =
SessionTime[] - time; here = Close[str]
DateString[]
314159 digits of the constant took 3 tries due to hardware failure. Finishing on September 18, 2012, I computed 314159 digits, taking 59 GB of RAM. The digits came from the Mathematica 8.0.4 code
DateString[]
NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]},
WorkingPrecision -> 314169, Method -> "AlternatingSigns"] // Timing
DateString[]
Sam Noble of Apple computed 1,000,000 digits of C_{MRB} in 18 days 9 hours 11 minutes 34.253417 seconds.
Finishing on Dec 11, 2012, Richard Crandall, an Apple scientist, computed 1,048,576 digits
in a lightning-fast 76.4 hours computation time (from the timing command). That's on a 2.93 GHz 8-core Nehalem.
In Aug of 2018, I computed 1,004,993 digits of C_{MRB} in 53.5 hours with 10 DDR4 RAM (of up to 3000 MHz) supported processor cores overclocked up to 4.7 GHz! Search this post for "53.5" for documentation.
Sept 21, 2018: I computed 1,004,993 digits of C_{MRB}
in 50.37 hours of absolute time (35.4 hours computation time) with 18
(DDR3 and DDR4) processor cores! Search this post for "50.37 hours"
for documentation.**
On May 11, 2019, I computed over 1,004,993 digits, using 28 kernels
on 18 DDR4 RAM (of up to 3200 MHz) supported cores overclocked up to
5.1 GHz in 45,5 hours of absolute time and only 32.5 hours of computation time! Search 'Documented in the attached ":3 fastest
computers together 3.nb." ' for the post that has the attached documenting notebook.
On 10/19/20, using 3/4 of the MRB constant supercomputer 2, I finished an over 1,004,993 digits computation of C_{MRB} in 44 hours of absolute time -- see https://www.wolframcloud.com/obj/bmmmburns/Published/44%20hour%20million.nb for documentation.
I computed a little over 1,200,000 digits of C_{MRB} in 11
days, 21 hours, 17 minutes, and 41 seconds (finishing on March 31, 2013). I used a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz.
On May 17, 2013, I finished a 2,000,000 or more digit computation of C_{MRB}, using only around 10GB of RAM. It took 37 days 5 hours 6 minutes 47.1870579 seconds. I used my six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz.
A previous world record computation of C_{MRB} was finished on Sun 21 Sep 2014 at 18:35:06. It took 1 month 27 days 2 hours 45 minutes 15 seconds. The processor time from the 3,000,000+ digit computation was 22 days. I computed the 3,014,991 digits of C_{MRB} with Mathematica 10.0. I Used my new version of Richard Crandall's code in the attached 3M.nb, optimized for my platform and large computations. I also used a six-core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz with 64 GB of RAM of which only 16 GB was used. Can you beat it (in more number of digits, less memory used, or less time taken)? This confirms that my previous "2,000,000 or more digit computation" was accurate to 2,009,993 digits. they were used to check the first several digits of this computation. See attached 3M.nb for the full code and digits.
Finished on Wed 16 Jan 2019 19:55:20, I computed over 4 million digits of C_{MRB}.
It took 4 years of continuous tries. This successful run took 65.13 days computation time, with a processor time of 25.17 days, on a 3.7 GHz overclocked up to 4.7 GHz on all cores Intel 6 core computer with 3000 MHz RAM. According to this computation, the previous record, 3,000,000+ digit computation, was accurate to 3,014,871 decimals, as this computation used my algorithm for computing n^(1/n) as found in chapter 3 in the paper at
https://www.sciencedirect.com/science/article/pii/0898122189900242
and the 3 million+ computation used Crandall's algorithm. Both algorithms outperform Newton's method per calculation and iteration.
See attached notebook.
M R Burns' algorithm:
x = SetPrecision[x, pr];
y = x^n; z = (n - y)/y;
t = 2 n - 1; t2 = t^2;
x =
x*(1 + SetPrecision[4.5, pr] (n - 1)/t2 + (n + 1) z/(2 n t) -
SetPrecision[13.5, pr] n (n - 1) 1/(3 n t2 + t^3 z));
(*N[Exp[Log[n]/n],pr]*)
Example:
ClearSystemCache[]; n = 123456789;
(*n is the n in n^(1/n)*)
x = N[n^(1/n),100];
(*x starts out as a relatively small precision approximation to n^(1/n)*)
pc = Precision[x]; pr = 10000000;
(*pr is the desired precision of your n^(1/n)*)
Print[t0 = Timing[While[pc < pr, pc = Min[4 pc, pr];
x = SetPrecision[x, pc];
y = x^n; z = (n - y)/y;
t = 2 n - 1; t2 = t^2;
x = x*(1 + SetPrecision[4.5, pc] (n - 1)/t2 + (n + 1) z/(2 n t)
- SetPrecision[13.5, pc] n (n - 1)/(3 n t2 + t^3 z))];
(*You get a much faster version of N[n^(1/n),pr]*)
N[n - x^n, 10]](*The error*)];
ClearSystemCache[]; n = 123456789; Print[t1 = Timing[N[n - N[n^(1/n), pr]^n, 10]]]
Gives
{25.5469,0.*10^-9999984}
{101.359,0.*10^-9999984}
R Crandall's algorithm:
While[pc < pr, pc = Min[3 pc, pr];
x = SetPrecision[x, pc];
y = x^n - n;
x = x (1 - 2 y/((n + 1) y + 2 n n));];
(*N[Exp[Log[n]/ n],pr]*)
Example:
ClearSystemCache[]; n = 123456789;
(*n is the n in n^(1/n)*)
x = N[n^(1/n)];
(*x starts out as a machine precision approximation to n^(1/n)*)
pc = Precision[x]; pr = 10000000;
(*pr is the desired precision of your n^(1/n)*)
Print[t0 = Timing[While[pc < pr, pc = Min[3 pc, pr];
x = SetPrecision[x, pc];
y = x^n - n;
x = x (1 - 2 y/((n + 1) y + 2 n n));];
(*N[Exp[Log[n]/n],pr]*)
N[n - x^n, 10]](* The error*)]; Print[
t1 = Timing[N[n - N[n^(1/n), pr]^n, 10]]]
Gives
{32.1406,0.*10^-9999984}
{104.516,0.*10^-9999984}
More information is available upon request.
- Finished on Fri 19 Jul 2019 18:49:02, I computed over 5 million digits of C_{MRB}.
Methods described in the reply below that starts with "Attempts at a 5,000,000 digit calculation ."
For this 5 million calculation of MRB using the 3 node MRB supercomputer:
processor time was 40 days.
and the actual time was 64 days.
That is faster than the 4 million digit computation using just one node.
- I finally computed 6,000,000 digits of the MRB constant after 8 tries in 19 months. (Search "8/24/2019 It's time for more digits!" below.) finishing on Tue 30 Mar 2021 22:02:49 in 160 days.
The MRB constant supercomputer 2 said the following:
Finished on Tue 30 Mar 2021 22:02:49. Processor and actual time were
5.2881585937510^6 and 1.3893572053630110^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!!!
Also, 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 that many decimals are in common with the 6,000,000+ digit computation.
I developed this informal catalog of formulas for the MRB constant with over 20 years of research and ideas from users like you.
12/19/2021
I found several MeijerG functions for CMRB. The search for it began with the following:
On 10/10/2021, I found the following proper definite integral for
CMRB.
See a to infinity to 0 to 1 CMRB.
As I mentioned in another message, this leads to almost identical
proper integrals for CMRB and its integrated analog.
See notebook here.
Speaking of its integrated analog (M2), here is a MeijerG function for it.
M2= where
b_{h}−b_{n}+2+1,h≠n+2.
Here, according to Wikipedeia,
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]
I wonder if there is one for the MRB constant sum (CMRB)?
The first one is an approximation with a very small error bound, that has exactly the same form as the MeijerG for the Integrated analog (M2):
In Mathematica:
CMRB = 0.1878596424620671202485179340542732300559030949001387861720046\
8408947723156466021370329665443217278;
f[n_] := MeijerG[{{},
Table[1, {n + 1}]}, {Prepend[
Table[0, n + 1], -n + 1], {}}, \[Pi] Csch[370/273]^2];
CMRB - Table[Sum[Pi^(n - 1)*f[n], {n, 1, x}], {x, 1,21}] - ((5*Zeta[3])/49 + (9*Pi)/5)/10^11
Out[119]= {0.0804780779739663286222710940165737883237,
0.0260950162762931257068842761032688030041,
0.0067510963494559934609016612807180221284,
0.0014476338998533471551912455134999059581,
0.0002645675640949217195085430052601079962,
0.0000420881530812856081367149341809520137, 5.924229696149373092489757488043506810^-6, 7.47486453710322405997379003129573610^-7, 8.5440753846282422294205932072110710^-8, 8.925132588887945725026787922447010^-9, 8.58305996870284382155122527102010^-10, 7.6465028353202257759222949619310^-11, 6.344754783700939788201008719510^-12, 4.92642139051885657472945542710^-13, 3.5941596516184972891305649110^-14, 2.472821994400897603983403910^-15, 1.60978329246909032229580710^-16, 9.961088991741776816029910^-18, 6.04228067169466001641110^-19, 5.2880045649360047197310^-20, 2.19087872234730798254*10^-20}
The closeness of the forms for this MeijerG function for CMRB and M2 has got me to suspect that there exist nearly identical exact forms for both. I've done a lot of searching, but no luck so far!
However, the MeijerG function for CMRB has several exact forms. Here are two subtly distinct ones using an algorithm I will prove gives some valid results.
1.
CMRB=
f[x_]=(-1)^x (x^(1/x)-1);CMRB = NSum[f[x], {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100];
f1[x_] = MeijerG[{{(
Log[x] + Log[-E^((1/x)) ((-1)^x - (-1)^x x^(1/x))])/
Log[x]}, { }}, {{}, {}}, x ];
CMRB -
NSum[f1[x], {x, 2, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100]
Out[699]= -1.86952*10^-93
2.
CMRB=
f[x_]=(-1)^x (x^(1/x)-1);CMRB = NSum[f[x], {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100];
f2[x_] = MeijerG[{{}, { }}, {{Log[-E^x ((-1)^x - (-1)^x x^(1/x))]/
Log[x]}, {}}, x ];
CMRB -
NSum[f2[x], {x, 2, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100]
Out[702]= -1.86952*10^-93
This is great, but the algorithm I made up that gives a MeijerG series for some f, is not unique to functions of the MRB constant.
For at least one other function,
f[x_] = (-1)^x Log[x]/x; s =
NSum[f[x], {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100];
f1[x_] = MeijerG[{{(Log[x] + Log[-E^((1/x)) (f[x])])/
Log[x]}, {}}, {{}, {}}, x];
s + NSum[f1[x], {x, 2, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 100]
Next, is how I found the formulas and arrived at the conditions, "P is never 0 and the same is true for x and Log[x]," for the sum of h, P, to equal its sum of MeijerG (h...,x):
Reduce[MeijerG[{{h}, {}}, {{}, {}}, x] == P, h]
Here is a Mathematica assisted proof that shows one of the MRB constant MeijerG sums is correct.
This gives a general formula for this form of MeijerG:
In[39]:= MeijerG[{{h}, {}}, {{}, {}}, x]
Out[39]= E^(-1/x) x^(-1 + h)
This shows that when you "load" that form with the input I gave, the result is (-1)^(1 + x) (-1 + x^(1/x)).
In[40]:= E^(-1/x) x^(-1 + h) /.
h -> (Log[x] + Log[-E^((1/x)) (f[x])])/Log[x]
Out[40]= (-1)^(1 + x) (-1 + x^(1/x))
(-1)^(1 + x) (-1 + x^(1/x)) is -((-1)^x ( x^(1/x)-1)
Then finally, the MRB constant is defined to be the alternating sum of ((-1)^x ( x^(1/x)-1). QED
Either awesome or trivial, depending on how you look at it: the multitudinous formulas for the MRB constant being computed from f[x_]=(-1)^x (x^(1/x)-1); CMRB = Sum[f[x], {x, 1, Infinity}], all have a MeijerG analog.
I just said, "The closeness of the forms for this MeijerG function for CMRB and M2 has got me to suspect that there exist nearly identical exact forms for both."
Here is one candidate for a CMRB MeijerG analog having exactly the same form as the M2 MeijerG algorithm:
In[94]:= f[n_] :=
MeijerG[{{},
Table[1, {n + 1}]}, {Prepend[
Table[0, n + 1], -n + 1], {}}, -I \[Pi]];
,
Shown above.
In[87]:= g(x_)=(-1)^x (1-(x+1)^(1/(x+1)));
In[88]:= term =
NIntegrate[((I (g[I t] - g[-I t])))/(E^(2 Pi t) - 1), {t, 0,
Infinity}, WorkingPrecision -> 100, Method -> "GlobalAdaptive"]
Out[88]= 0.\
1170836031505383167089899122239912286901483986967757585888318959258587\
7430027817712246477316693025869 +
0.0473806170703507861072094065026036785731528996931736393319610009025\
6586758807049779050462314770913485 I
Out[98]= -1.73146646461074205*10^-14 + 9.19966028921191019*10^-14 I
According to the first and third primary proofs shown below along with the demonstration prefixed by the phrase "So far I came up with",
it can be shown that
12/18/2021
Here is a great way to compute "d" digits of C_{MRB} quickly using the identity found in my discovery dated 12/5/2021 (listed immediately after this one):
re.
HoldForm[Assuming[Element[x, Integers] && x > 0 && Element[k, Integers] && k > 0,
FullSimplify[((-1)^x*((x^(1/x) - 1)*k! - (k*x^(1/x)*Log[x])/x))/(k*(k - 1)!)]]
Full Cloud notebook found here, and below, where all of these are compared:
In[18]:= ClearSystemCache[]
In[19]:= f[x_] = (-1)^x (x^(1/x) - 1);
In[20]:= Timing[
CMRB = NSum[f[x], {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 2000];]
Out[20]= {1.0625, Null}
In[21]:= Timing[
CMRB - NSum[(((-1)^
x*((-1 + x^x^(-1))*k! -
k*x^x^(-1)*(Gamma[k] - Gamma[k, Log[x]/x])))/(k*(-1 +
k)!)) /. k -> 500, {x, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 1000]]
Out[21]= {1.8125, -3.*10^-998}
In[45]:= ClearSystemCache[]
In[46]:= Timing[
CMRB - NSum[(((-1)^
x*((-1 + x^x^(-1))*k! -
k*x^x^(-1)*(Gamma[k] - Gamma[k, Log[x]/x])))/(k*(-1 +
k)!)) /. k -> 1000, {x, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 2000]]
Out[46]= {8.15625, 3.*10^-998}
In[23]:= Assuming[k \[Element] Integers && k > 0,
FullSimplify[(((-1)^
x*((-1 + x^x^(-1))*k! -
k*x^x^(-1)*(Gamma[k] - Gamma[k, Log[x]/x])))/(k*(-1 + k)!))]]
Out[23]= (-1)^x (-1 + (x^(1/x) Gamma[k, Log[x]/x])/Gamma[k])
In[25]:= ClearSystemCache[]
In[24]:= f[x_] = (-1)^x (x^(1/x) - 1);
In[26]:= Timing[
CMRB = NSum[f[x], {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 1000];]
Out[26]= {0.6875, Null}
In[27]:= ClearSystemCache[]
In[28]:= Timing[
CMRB - NSum[((f[x]*Gamma[k, Log[x]/x])/Gamma[k]) /. k -> 2000, {x, 1,
Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 1000]]
Out[28]= {1.73438, 0.*10^-999}
In[32]:= ClearSystemCache[]
In[33]:= Timing[
CMRB - NSum[((f[x]*Gamma[k, Log[x]/x])/Gamma[k]) /. k -> 4000, {x, 1,
Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 2000]]
Out[33]= {6.92188, 0.*10^-1999}
ClearSystemCache[]
In[38]:= Timing[
CMRB - NSum[((f[x]*Gamma[k, Log[x]/x])/Gamma[k]) /. k -> 3500, {x, 1,
Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 2000]]
Out[38]= {6.21875, 0.*10^-1999}
Both of the following were done on Wolfram Cloud.
In[14]:= ClearSystemCache[]
Timing[
CMRB - NSum[(-1)^
x*(-1 + x^x^(-1) - (x^(-1 + x^(-1))*Log[x])/Gamma[k]) /.
k -> 500, {x, 1, Infinity}, Method -> "AlternatingSigns",
WorkingPrecision -> 1000]]
Out[15]= {1.9243,0.*^-999}
That last one came about by the following exercise that substantially hastened the convergence of
*by removing the Gamma and incomplete Gamma operators, yet leaving its "second input."
So, it might be less trivial than two series being added together. Besides, the series with (x^(-1+x^(-1))Log[x])/Gamma[k] in it is only conditionally convergent.
cf
In[170]:= ClearSystemCache[]
In[10]:= Timing[
CMRB = NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity},
Method -> "AlternatingSigns", WorkingPrecision -> 1000];]
Out[10]= {1.62532,Null}
12/5/2021
I discovered the following series for C_{MRB}, from the following double sum, which converges in one slow iteration, and to more digits as "k" increases. P.S. The differences of its large in size "partial sums of limits" telescope down to expressions with very few terms. (Indicating the size of each sum.)
and factoring out a "k" gives
Dividing by the Gamma k, we get,
C_{MRB} =.
That implies,
At this point, we know that x^(1/x) ≠ 0, so, then iff the identity is true, we will be able to show that its cofactor to the term added to x^(1/x)-1is 0. So, now it becomes trivial to prove.
Which we find obviously true by liking it to Limit[1/h - h/h, h -> Infinity]=-1, and since Mathematica says:
In[495]:= Limit[Gamma[k, Log[x]/x]/Gamma[k],
k -> Infinity]
Out[495]= 1
.
So, we have shown the cofactor is 0, and thus the identity is true, and the double sum equals the MRB constant.
Let l be the partial sums of the MRB constant are as shown in the following mini-notebook, https://www.wolframcloud.com/download/bmmmburns/Published/1292021_a(2).nb . They are not the same
as, ll, the partial sums found for
C_{MRB,}
in the 11/14/2021 discovery described next.
But, ll can be formed by a simple combination of l.
And l and ll can be brought together in certain combinations to accelerate the convergence of CMRB.
See this cloud notebook:
Here is the cloud notebook I discovered it in while working from the other direction.
11/14/2021
Here is a standard notation for the above mentioned
C_{MRB,}
.
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:
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
here.
Lest we forget, as seen in a late
reply below and here.
(proofs and more example code follows)
On 10/18/2021
, I found the following triad of pairs of integrals summed from -complex infinity to +complex infinity.
You can see it worked here.
In[1]:= n = {1, 25.6566540351058628559907};
In[2]:= g[x_] = x^(n/x);
-1/2 Im[N[
NIntegrate[(g[(1 - t)])/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]
Out[3]= {0.18785964246206712025, 0.18785964246206712025}
In[4]:= g[x_] = x^(n/x);
1/2 Im[N[NIntegrate[(g[(1 + t)])/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]
Out[5]= {0.18785964246206712025, 0.18785964246206712025}
In[6]:= g[x_] = x^(n/x);
1/4 Im[N[NIntegrate[(g[(1 + t)] - (g[(1 - t)]))/(Sin[\[Pi] t]), {t, -Infinity I,
Infinity I}, WorkingPrecision -> 60], 20]]
Out[7]= {0.18785964246206712025, 0.18785964246206712025}
Therefore, bringing
back to mind, we joyfully find,
as shown next.
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 C_{MRB} (great for integer arithmetic because
(1-1/n)^k=(n-1)^k/n^k. )
So, using only integers, and sufficiently large ones in place of infinity, we can use
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 C_{MRB}.
On 9/5/2021 I added the following MRB constant integral over an unusual range.
See proof here.
On Pi Day, 2021, 2:40 pm EST,
I added a new MRB constant integral.
We see many more integrals for C_{MRB}.
We can expand
into the following.
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
we get the following set of formulas that all equal C_{MRB}:
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
See
this notebook from the wolfram cloud
for justification.
Also, in terms of the Euler-Riemann zeta function,
C_{MRB} =
Furthermore, as ,
according to user90369 at StackExchange, C_{MRB} can be written as the sum of zeta derivatives similar to the eta derivatives discovered by Crandall.
Informations about ?^{(j)}(k) please see e.g. here, formulas (11)+(16)+(19).
In the light of the parts above, where
C_{MRB}
=
=
=
as well as
an internet scholar going by the moniker "Dark Malthorp" wrote:
Primary Proof 1
C_{MRB}=, based on
CMRB
is proven below by an internet scholar going by the moniker "Dark Malthorp."
Primary Proof 2
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 rigorouslyconsidering the conditionally convergent sum, below that. Then the right half is a Taylor expansion of ?(s) around s = 0.
At
https://math.stackexchange.com/questions/1673886/is-there-a-more-rigorous-way-to-show-these-two-sums-are-exactly-equal,
it has been noted that "even though one has cause to be a little bit wary around formal rearrangements of conditionally convergent sums (see the Riemann series theorem), it's not very difficult to validate the formal manipulation of Helms. The idea is to cordon off a big chunk of the infinite double summation (all the terms from the second column on) that we know is absolutely convergent, which we are then free to rearrange with impunity. (Most relevantly for our purposes here, see pages 80-85 of this document, culminating with the Fubini theorem which is essentially the manipulation Helms is using.)"
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=
Which is the same as
because changing the upper limit to 2N + 1 increases MI by 2i/?.
MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .
Plugging in equations [5] and [6] into equation [2] gives us:
Now take the limit as N?? and apply equations [3] and [4] :
He went on to note that
I wondered about the relationship between CMRB and its integrated analog and asked the following.
So far I came up with
Another relationship between the sum and integral that remains more unproven than I would like is
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.
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.