Message Boards Message Boards

Try to beat these MRB constant records!

If you see this text, refresh the page in order to see the images.

Here's everything this author has ever learned, spend it well!

This author was inspired by the awe, beauty, and mystery of numbers, and wondered if God would grant him some unique insight and wisdom to explore them. He dreamed of becoming an artistic analyst, a musical mathematician, or even a visionary of scientific secrets, long before he knew what a mathematician was. He searched for inspiration in the numbers that appealed to him, that had beauty and meaning, and that led him to investigate a remarkable and intriguing sum that he could not find anywhere else. For his efforts, someone started calling him an amateur mathematician and it the MRB constant.

The MRB constant is a fascinating mathematical object that is still under investigation. It is possible that further research will reveal even more interesting properties about the constant, and perhaps other parts of mathematics. For example, a recent advancement in MRB constant formulas connecting the Dirichlet eta to nth roots shown in this discussion CTRL+f "The MRB constant relates to the divergent series:", yields a proof of the previously proposed concept that the MRB constant connects such ideas together.

He is just an ordinary person like you, who stumbled upon a fascinating discovery that he wanted to share with the world. He now knows that there are many experts in the field of series who have devoted their lives to this subject. He respects their work and does not claim to have found anything new or groundbreaking. However, he's curious and passionate about the MRB constant, which is a remarkable number that appears in many series. He hopes that you will join in this journey of exploration and learning, as he presents his findings and thoughts on this topic. He would greatly appreciate your feedback and insights, as he is always eager to learn more and improve his understanding. He also wants to acknowledge the contributions of several people who have helped along the way, either by providing data, code, or suggestions. Without them, this discussion would not be possible.

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



POSTED BY: Marvin Ray Burns.

If you see this text, the images are not showing. Refresh the page. The first 100 partial sums of {the CMRB series.}


For the best viewing, wait a minute until the word LaTeX in the LaTex script is centered below.

$$\LaTeX$$

If the phrase [Math Processing Error] is shown, or the LATEX script has vanished from the center of the above line, some of the math below might be missing or appear in the LaTex code instead of the script.

For easy navigation, use the CTRL+f keys on your keyboard. Cues in the forms of §'s and keywords in quotes are provided in the CTRL+f "Index".

If the header and the words

Reply | Flag

are shown at the same time in any of the following replies, refresh the page to see them.







'




Index

The first post

§1. Q&A:

§2 Analyze the CTRL+f."prototypical series" for the MRB constant, Sn^(1/n)-1 and find its "completion" (a related series that is absolutely convergent).

(Select § with the given number or the keywords in quotes, and then press the

CTRL+f keys on your keyboard to move to that section.)

§3. Is that series convergent?

§4. Is -1 the only term that series is convergent for?

§5. Is that series absolutely convergent?

§6. Is that series "efficient?" (defined as how it compares to other series and integrals that compute CMRB in speed and computational cost.)

§7. My claim to the MRB constant (CMRB), or a case of calculus déjà vu?

§8. Where is it found?

§9. What exactly is it?

Second post.

§B CTRL+f "Rational results" while summing (CMRB).

Third post.

§10. How it all began,

§11. Scholarly works

Fourth post.

§12. CMRB and its applications

Also see

MOPAC

for where the MRB constant's value, to a precision of 2 one-billionth i.e., 0.18785964, is arrived at by measuring a gradient of the silicon atom in the Phenakite (Be2SiO4) molecule by openmopac.

Fifth post.

§13. The why and what of the CMRB Records,

Many more informative posts

including, but not limited to

For section A, where all CMRB records have been checked, highlight text between quotes in

§A. Possibly the most epigrammatic closed forms for checking up to 10^10 digits of CMRB!

"Possibly the most epigrammatic closed forms used for checking up to 6,500,000 digits of CMRB!"

then push CTRL+f on keyboard.

For section 0, highlight text between quotes in

"§0. Wolfram+AI is the quintessential team evaluating the MRB constant."

then push CTRL+f on keyboard.


§1.

Q&A:

Q: What is the MRB constant ( CMRB)?

A:

The MRB constant is a mathematical constant related to the summation of an alternating series involving the nth root of n. It is named after Marvin Ray Burns, who discovered the constant in 1999. The MRB constant is defined as the upper limit of the partial sums. No closed-form expression is known for the MRB constant, and it is not known whether it is algebraic or transcendental, nor even whether it is rational or irrational. However, it has been computed and proven to 6,500,000 digits of precision with no termination or obvious period of digits¹.

I hope that helps!

Source: Conversation with Bing, 7/30/2023
(1) Try to beat these MRB constant records! - Online Technical Discussion Groups—Wolfram Community. https://community.wolfram.com/groups/-/m/t/366628.
(2) MRB constant - Wikipedia. https://en.wikipedia.org/wiki/MRB_constant.
(3) (PDF) MRB constant Definition | Marvin R Burns - Academia.edu. https://www.academia.edu/104444631/MRB_constant_Definition.

Q: What can you expect from reading about CMRB and its record computations?

A:

As you see, the war treated me kindly enough, in spite of the heavy gunfire, to allow me to get away from it all and take this walk in the land of your ideas.

— Karl Schwarzschild (1915), “Letter to Einstein”, Dec 22

Q: Can you calculate more digits of CMRB?

A:

With the availability of high-speed electronic computers, it is now quite convenient to devise statistical experiments for the purpose of estimating certain mathematical constants and functions.

Copyright © 1966 ACM
(Association for Computing Machinery)

New York, NY, United States

Q: How can you compute them?

A:

The value of $\pi$ has engaged the attention of many mathematicians and calculators from the time of Archimedes to the present day, and has been computed from so many different formulae, that a complete account of its calculation would almost amount to a history of mathematics.

—  James Glaisher (1848-1928)

Q: Why should you do it?

A:

While it is never safe to affirm that the future of Physical Science has no marvels in store even more astonishing than those of the past, it seems probable that most of the grand underlying principles have been firmly established and that further advances are to be sought chiefly in the rigorous application of these principles to all the phenomena which come under our notice. It is here that the science of measurement shows its importance — where quantitative work is more to be desired than qualitative work. An eminent physicist remarked that the future truths of physical science are to be looked for in the sixth place of decimals.

 —  Albert A. Michelson (1894)

Q: What are its first 500 digits?

A:

In

WolframAlpha["500 digtits of the MRB constant", {{"Result", 1}, "Output"}]

Out[93]= \ HoldComplete[0.\ 1878596424620671202485179340542732300559030949001387861720046840894772\ 3156466021370329665443310749690384234585625801906123137009475922663043\ 8929348896184120837336626081613602738126379373435283212552763962171489\ 3217020762820621715167154084126804483635416719985197680252759893899391\ 4457983505561350964852107120784442309586812949768852694956420425558648\ 3670441042527952471060666092633974834103115781678641668915460034222258\ 8380025455396892947114212218910509832871227730802003644521539053639505\ 5332203471]

Q: Is its decimal expansion a normal number?

A

According to Wolfram MathWorld, "A normal number is an irrational number for which any finite pattern of numbers occurs with the expected limiting frequency in the expansion in a given base (or all bases). For example, for a normal decimal number, each digit 0–9 would be expected to occur 1/10 of the time."

We do not know if the MRB constant is irrational; this Demonstration looks at how normal its first 5000 digits appear to be. For comparison, we also consider the digits of ; its first 30 million digits are very uniformly distributed.

Q: Why are those digits there?

A:

[The principle, "nothing is without reason (nihil est sine ratione), or there is no effect without a cause"] must be considered one of the greatest and most fruitful of all human knowledge, for upon it is built a great part of metaphysics, physics, and moral science. (G VII 301/L 227).

—  Gottfried Wilhelm Leibniz (1646–1716)

Q: What practical purpose is there in calculating them?

A:

Knowledge of the digits of mathematical constants can have various applications in mathematics, science, and technology. For example:

  • The digits of π can be used to test the randomness and performance of pseudorandom number generators, which are essential for cryptography, simulations, and gaming¹.
  • The digits of e can be used to calculate compound interest, model population growth, and analyze the distribution of prime numbers².
  • The digits of φ can be used to design aesthetic proportions, such as the golden rectangle, the golden spiral, and the Fibonacci sequence³.
  • The digits of i can be used to represent complex numbers, which are useful for modeling phenomena such as electric currents, waves, and quantum mechanics⁴.

Some people also enjoy finding patterns and hidden messages in the digits of mathematical constants, such as memorizing them, composing music with them, or searching for their birthdays in them. This can be a fun and challenging way to appreciate the beauty and mystery of mathematics.

Do you have a favorite mathematical constant? Why do you like it?

Source: Conversation with Bing, 8/19/2023
(1) Mathematical constant - Wikipedia. https://en.wikipedia.org/wiki/Mathematical_constant.
(2) Mathematical Constants - Cambridge University Press & Assessment. https://assets.cambridge.org/052181/8052/sample/0521818052ws.pdf.
(3) Constant (mathematics) - Wikipedia. https://en.wikipedia.org/wiki/Constant_%28mathematics%29.
(4) List of mathematical constants - Wikipedia. https://en.wikipedia.org/wiki/List_of_mathematical_constants.
(5) undefined. http://www.cambridge.org.
(6) A Resource List of Mathematical Constants - Barcodes Inc.. https://www.barcodesinc.com/articles/resource-list-mathematical-constants.htm.
(7) Constant - Math.net. https://www.math.net/constant.
(8) The Most Important Numbers in the World - Business Insider. https://www.businessinsider.com/most-important-numbers-2012-7.

§2 The MRB constant relates to the divergent series: divegrent series

=DNE

The divergent sequence of its partial sums has two accumulation points with an upper limiting value or limsup known as the MRB constant (CMRB), and a liminf of CMRB-1: enter image description here

So, out of the many series for CMRB, first analyze the sum prototype or prototypical series], i.e., the conditionally convergent series, the sum of two divergent ones: {(-1)^k k^(1/k) and (-1)^n)}. {CMRB} =Sn^(1/n)-1

Because the Riemann series theorem states that, by a suitable rearrangement of terms, a conditionally convergent series may be made to converge to any desired value, or to diverge, we will quickly derive an absolutely convergent one. (In a sense it is the "completion" of the prototypical series.)

To find its completion, we add the terms of the series for another conditionally convergent series and subtract its sum,

WHY? and HOW does that produce the absolutely convergent series? enter image description here

That process gives the absolutely and speedily convergent sum: enter image description here enter image description here

CTRL+f §9 for a full proof.

Here is how the speedily convergent sum compares with the prototype.



Concerning the sum prototype for CMRB

§3. Is the series convergent?

Proof of its convergence by Leibniz's criterion is shown next.

PROOF

Below, it is shown by the Squeeze theorem (sandwich theorem) and by plotting the following series, the qualifications for the Leibniz criterion (alternating series test) are satisfied for the MRB constant (CMRB) in

CMRB enter image description here

by showing a(n)=(n^{1/n}-1)>0 is monotonically decreasing for $n≥3$ and has a limit as n goes to infinity of zero. Of course, $\sum_1^3(-1)^n(n^{1/n}-1)$, converges, and the sum of two convergent series converges.

Here is a direct proof from physicsforums

that enter image description here because enter image description here proof

By utilizing the Squeeze theorem (also known as the Sandwich theorem) and plotting techniques, it has been demonstrated that the Leibniz criterion (alternating series test) is valid for the alternating sum of a(n) = (n^(1/n) - 1) > 0. Moreover, for n greater than 1, the derivative equals zero solely at the value of e, and there are no additional critical points at which the plot ceases to decline. As a result, a(n) = (n^(1/n) - 1) > 0 decreases monotonically for n greater than or equal to 3 and has a limit of zero as n approaches infinity. Ultimately, the series $\sum_1^3(-1)^n(n^{1/n}-1)$ converges, and the sum of two convergent series is also convergent. Thus, the CMRB Sum prototype series is convergent. ∎

Likewise, we know

enter image description here

where eta is the Dirichlet Eta Function, without defining the zeta function first.

It converges only because CMRB does

.

The MRB constant is a mathematical constant that is related to the convergence of the logarithm function. The logarithm function is a function that takes a positive number as an input and returns the power to which 10 must be raised to get that number. For example, the logarithm of 100 is 2, because 10 raised to the power of 2 is 100.

The MRB constant is defined as the limit of the following series:

MRB is the limit of the sums of (-1)^n (n^(1/n)-1) as n goes to infinity Learn more This series is known to converge, and its value is approximately 0.187859642. The convergence of the MRB constant implies the convergence of the logarithm function, because the logarithm function can be expressed as a limit of a series that is similar to the MRB constant.

In particular, the logarithm of 2 can be expressed as the limit of the sums of (-1)^(n+1) (1/n) as n goes to infinity. Learn more This limit is less than or equal to the MRB constant which is known to converge. That is because for integer n>2, n^(1/n)-1>1/n, Therefore, the logarithm of 2 also converges.

The convergence of the logarithm function is an important mathematical property, because it allows us to calculate the logarithm of any positive number. This property is used in many areas of mathematics, including calculus, statistics, and computer science.

enter image description here






§4 Next, ask and observe, question

Short explanation As shown soon (CTRL+f "As for efficiency" ).



§5. Is that series, enter image description here absolutely convergent?

The following criterion works remarkably well in determining its absolute convergence.

divergent proof

Plot[{n^(1/n) - 1, 1/n}, {n, 1, Infinity}, 
 PlotLegends -> LineLegend["Expressions"]]

plot

...showing its terms are larger than those of the divergent Harmonic Series.



§6 As for efficiency, this discussion presents several series that converge much faster for CMRB. Here are a few of their convergence rates. The following expressions show the sum followed by the closeness to zero of their result after a certain number of partial summations.

ALG 1 proposed here

For how more efficient forms compare,

CTRL+f "the rate of convergence" of 3 major forms.





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

Amateurs have made a few significant discoveries, as discussed in enter image description here here. This amateur has tried his best to prove his discoveries and has often asked for help. Great thanks to all of those who offered a hand!

As he went more and more public with his discoveries, making several attempts to see what portions were original, he concluded from these investigations that the only original thought was the obstinacy to think anything meaningful could be found in the infinite sum shown next. CMRB sum Nonetheless, someone might have a claim to this thought to whom it has not given proper credit. Hence (apologies!) The last thing needed is another calculus war, this time for a constant. However, as Newton said concerning Leibniz's claim to calculus, anyone's thought was published after his, “To take away the Right of the first inventor and divide it between him and that other would be an Act of Injustice.” [Sir Isaac Newton, The Correspondence of Isaac Newton, 7 v., edited by H. W. Turnbull, J. F. Scott, A. Rupert Hall, and Laura Tilling, Cambridge University Press, 1959–1977: VI, p. 455]

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

enter image description here

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

(the calculus war for CMRB)

CREDIT

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

'

From Wikipedia, the free encyclopedia:

'

The calculus controversy (German: Prioritätsstreit, "priority dispute") was an argument between the mathematicians Isaac Newton and Gottfried Wilhelm Leibniz over who had invented calculus.

enter image description here

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

enter image description here

(Leibniz's notation as published in the scholarly journal Acta Eruditorum [Reports of Scholars])

Whether or not we divide the credit between the two pioneers,

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

Newton came to calculus as part of his investigations in physics and geometry. He viewed calculus as the scientific description of the generation of motion and magnitudes. In comparison, Leibniz focused on the tangent problem and came to believe that calculus was a metaphysical explanation of the change. Importantly, the core of their insight was the formalization of the inverse properties between the integral and the differential of a function. This insight had been anticipated by their predecessors, but they were the first to conceive calculus as a system in which new rhetoric and descriptive terms were created.[24] Their unique discoveries lay not only in their imagination but also in their ability to synthesize the insights around them into a universal algorithmic process, thereby forming a new mathematical system.

Like as Newton and Leibniz created a new system from the elaborate, confusing structure designed and built by their predecessors, Marvin Ray Burns' forerunners studied series for centuries leading to a labyrinth of sums, and then, came a "new scheme" for the CMRB "realities" to escape and stand out as famous in its own right!



§8.

it is defined in the following 31 places, most of which attribute it to my curiosity.

Here are the MRB constant's Wikipedia views vs those of the famous Euler's constant, e:

enter image description here



§9. CMRB

= B =

enter image description here

and from Richard Crandall (CTRL+f "** From Bing AI:") in 2012 courtesy of Apple Computer's advanced computational group, the following computational scheme using equivalent sums of the zeta variant, Dirichlet eta:

enter image description here enter image description here

The expressions Etam and eta0 denote the mth derivative of the Dirichlet eta function of m and 0, respectively.

The cj's are found by the code,

  N[ Table[Sum[(-1)^j Binomial[k, j] j^(k - j), {j, 1, k}], {k, 1, 10}]]

(* {-1., -1., 2., 9., 4., -95., -414., 49., 10088., 55521.}*)

** From Bing AI: -- enter image description here

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

n^(1/n)-1

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

enter image description here

enter image description hereenter image description here


enter image description here The integral forms for CMRB and MKB differ by only a trigonometric multiplicand to that of its analog.

enter image description here

In[182]:= CMRB = 
 Re[NIntegrate[(I*E^(r*t))/Sin[Pi*t] /. r -> Log[t^(1/t) - 1]/t, {t, 
    1, I*Infinity}, WorkingPrecision -> 30]]

Out[182]= 0.187859642462067120248517934054

In[203]:= CMRB - 
 N[NSum[(E^( r*t))/Cos[Pi*t] /. r -> Log[t^(1/t) - 1]/t, {t, 1, 
    Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 37], 
  30]

Out[203]= 5.*10^-30

In[223]:= CMRB - 
 Quiet[N[NSum[
    E^(r*t)*(Cos[Pi*t] + I*Sin[Pi*t]) /. r -> Log[t^(1/t) - 1]/t, {t, 
     1, Infinity}, Method -> "AlternatingSigns", 
    WorkingPrecision -> 37], 30]]

Out[223]= 5.*10^-30

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

Out[204]= 0.0707760393115292541357595979381 - 
 0.0473806170703505012595927346527 I

\


if the reply below doesn't say "Rational results" while summing (CMRB)." You'll need to refresh the page to see it.













POSTED BY: Marvin Ray Burns
42 Replies

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

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

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

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

enter image description here

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

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

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

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

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

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453

I just now retweaked the program. It is now

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

Feb 2015

Here are my best eta derivative records:

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

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

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

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

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

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

         Out[1]= {9.874863, Null}

Aug 2016

enter image description here

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

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275



 10,000        53667.6315476

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

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453


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

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

3752/127 ~=29.

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

2989/42 ~=72,

POSTED BY: Marvin Ray Burns

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

nice system!

POSTED BY: l van Veen

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

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

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

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

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

...including arbitrarily close approximation formulas for CMRB

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

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

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

In[63]:= 225897077238546^m - m

Out[63]= 496.99999999999999975304752932252481772179797865

In[62]:= 1668628852566227424415^m - m

Out[62]= 9700.9999999999999999994613109586919797992822178

In[61]:= 605975224495422946908^m - m

Out[61]= 8019.9999999999999999989515156294756517433387956

In[60]:= 3096774194444417292742^m - m

Out[60]= 10896.0000000000000000000000096284579090392932063

In[56]:= 69554400815329506140847^m - m

Out[56]= 19549.9999999999999999999999991932013520540825206

In[68]:= 470143509230719799597513239^m - m

Out[68]= 102479.000000000000000000000000002312496475978584

In[70]:= 902912955019451288364714851^m - m

Out[70]= 115844.999999999999999999999999998248770510754951

In[73]:= 2275854518412286318764672497^m - m

Out[73]= 137817.000000000000000000000000000064276966095482

In[146]:= 2610692005347922107262552615512^m - m

Out[146]= 517703.00000000000000000000000000000013473353420

In[120]:= 9917209087670224712258555601844^m - m

Out[120]= 665228.00000000000000000000000000000011062183643

In[149]:= 19891475641447607923182836942486^m - m

Out[149]= 758152.00000000000000000000000000000001559954712

In[152]:= 34600848595471336691446124576274^m - m

Out[152]= 841243.00000000000000000000000000000000146089062

In[157]:= 543136599664447978486581955093879^m - m

Out[157]= 1411134.0000000000000000000000000000000035813431

In[159]:= 748013345032523806560071259883046^m - m

Out[159]= 1498583.0000000000000000000000000000000031130944

In[162]:= 509030286753987571453322644036990^m - m

Out[162]= 1394045.9999999999999999999999999999999946679646


In[48]:= 952521560422188137227682543146686124^m - m

Out[48]=5740880.999999999999999999999999999999999890905129816474332198321490136628009367504752851478633240


In[26]:= 50355477632979244604729935214202210251^m - m

Out[26]=12097427.00000000000000000000000000000000000000293025439870097812782596113788024271834721860892874


In[27]:= 204559420776329588951078132857792732385^m - m

Out[27]=15741888.99999999999999999999999999999999999999988648448116819373537316944519114421631607853700001


In[46]:= 4074896822379126533656833098328699139141^m - m

Out[46]= 27614828.00000000000000000000000000000000000000001080626974885195966380280626150522220789167201350


In[8]:= 100148763332806310775465033613250050958363^m - m

Out[8]= 50392582.999999999999999999999999999999999999999998598093272973955371081598246


In[10]=  116388848574396158612596991763257135797979^m - m

Out[10]=51835516.000000000000000000000000000000000000000000564045501599584517036465406


In[12]:= 111821958790102917465216066365339190906247589^m - m

Out[12]= 188339125.99999999999999999999999999999999999999999999703503169989535000879619


In[33] := 8836529576862307317465438848849297054082798140^m - m

Out[33] = 42800817.00000000000000000000000000000000000000000000000321239755400298680819416095288742420653229


In[71] := 532482704820936890386684877802792716774739424328^m - m

Out[71] =924371800.999999999999999999999999999999999999999999999998143109316148796009581676875618489611792


In[21]:= 783358731736994512061663556662710815688853043638^m - m

Out[21]= 993899177.0000000000000000000000000000000000000000000000022361744841282020


In[24]:= 8175027604657819107163145989938052310049955219905^m - m

Out[24]= 1544126008.9999999999999999999999999999999999999999999999999786482891477\
944981


19779617801396329619089113017251584634275124610667^m - m
gives
1822929481.00000000000000000000000000000000000000000000000000187580971544991111083798248746369560.


130755944577487162248300532232643556078843337086375^m - m

gives 

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

(51 consecutive 9 s)

322841040854905412176386060015189492405068903997802^m - m

gives

3080353548.000000000000000000000000000000000000000000000000000019866002281287395703598786588650156

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

(52 consecutive 0 s)


310711937250443758724050271875240528207815041296728160^m - m

gives

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

(55 consecutive 9s)

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

(62 consecutive 9 s).

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

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

POSTED BY: Marvin Ray Burns

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

I DECLARE VICTORY!

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

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

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

  0.*10^-5024993

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

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

Attachments:
POSTED BY: Marvin Ray Burns

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

Distribution of digits

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

enter image description here

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

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

3,000,000 digits share a similar distribution:

enter image description here

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

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

Attachments:
POSTED BY: Marvin Ray Burns

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

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

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

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

POSTED BY: Marvin Ray Burns

Time for a quick memorial:

This discussion began on 1/20/2014.

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

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

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

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

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

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

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

1/20/2023 695,000 views (precisely nine years). That's an average of 211.5 views/hour, or one view every 17 seconds.

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

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

Along the lines of how normal the MRB constant is, I noticed the following about its original sum,

$\displaystyle{\sum_{n=1}^{\infty}(-1)^n(n^{1/n}-1)}.$

I wondered, (what would happen to the sum if you added smaller and smaller steps?)

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

enter image description here

`

  In[35]:= Re[
   NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^20}, 
    WorkingPrecision -> 70, Method -> "AlternatingSigns", 
    NSumTerms -> 2000]]

  Out[35]= -1.\
  999999749999999973333339999999998228052447182132376098872359604490555*\
  10^-14

  In[36]:= Re[
   NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^30}, 
    WorkingPrecision -> 70, Method -> "AlternatingSigns", 
    NSumTerms -> 2000]]

  Out[36]= -1.\
  999999749999999999999999997333333999999999999999999982280524444387501*\
  10^-24

  In[37]:= Re[
   NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^40}, 
    WorkingPrecision -> 70, Method -> "AlternatingSigns", 
    NSumTerms -> 2000]]

  Out[37]= -1.\
  999999749999999999999999999999999999733333399999999999999990562538808*\
  10^-34

  In[38]:= Re[
   NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^50}, 
    WorkingPrecision -> 70, Method -> "AlternatingSigns", 
    NSumTerms -> 2000]]

  Out[38]= -1.\
  999999749999999999999999999999999999999999999973243568040505517332039*\
  10^-44

In this case, finding exactly where the error starts is difficult for me. But let's assume the following is true.

In[5]:= Re[ NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^30}, WorkingPrecision -> 40, Method -> "AlternatingSigns"]]

Out[5]= -1.12250000000000000000000000002637761741*10^-28

In[6]:= Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 2/10^40},  WorkingPrecision -> 50, Method -> "AlternatingSigns"]]

Out[6]= -2.244999999999999999999999999999999999982964553611*10^-38

  In[39]:= p =  Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^200}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]]

Out[39]= \ -1.1224999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999887999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999999999999999999999999\ 9999999999999999999999999999999999999999999999999951865743238994910613\ ...*10^-198

In[41]:= Rationalize[N[Q100 = 10^98 p + 1, 200], 0]]

$$\frac{8908685968819599109131403118040089086859688195991091314031180400890868596881959910913140311804008907}{8908685968819599109131403118040089086859688195991091314031180400890868596881959910913140311804008908}$$

I think it's worth pointing out that the rational approximation consists, entirely, of repeating $$89086859688195991091314031180400's$$ except for the last digit of the numerator.

Some steps of multiples of powers of 10 also give solutions with many repeating 9s.

In[59]:= N[ Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 100]

Out[59]=-1.122499999999999999999999999999999999998879999999999999999999999999999999999995186574323899491061367*10^-38

In[54]:= N[Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/20^40}, WorkingPrecision -> 1000, Method ->"AlternatingSigns"]], 55]

Out[54]= \ -1.020907802740111947059631347656249999999999999999999074*10^-50

In[69]:= N[Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/50^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 150]

Out[69]= \ -1.2342018021785599999999999999999999999999999999999999999999999999998\ 6460030820316153243290828799999999999999999999999999999999999999993601\ 859835697267*10^-66

In[84]:= N[ Re[NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/200^40}, WorkingPrecision -> 1000, Method -> "AlternatingSigns"]], 200]

Out[84]= \ -1.0209078027401119470596313476562499999999999999999999999999999999999\ 9999999999999999999999990735577139406090041440222648816416040062904357\ 91015624999999999999999999999999999999999999637878099817017722*10^-90

I posted it at https://math.stackexchange.com/questions/4575530/sum-infty-textstylex-11-k-atopk-in-1-ldots-infty-1x-x1 to see if anyone can explain it.

I found the following that shows a little bit of what happens for smaller and smaller steps of powers 2 and 5, which are related to powers 10.

By a factor of pi, the imaginary part has at least as many repetitions of decimals.

In

N[Table[Im[
    NSum[(-1)^x (x^(1/x) - 1), {x, 1, Infinity, 1/10^n}, 
     WorkingPrecision -> 180, Method -> "AlternatingSigns"]], {n, 20, 
    50}], 100]/Pi

Out[216]= \
{-1.014999999999999999889749999999999999985380680380635051103404220561\
131468438815891294117640691851961*10^-37, \
-1.0149999999999999999889749999999999999998538068038063505110089362727\
15953551936726556669955860834527*10^-39, \
-1.0149999999999999999988974999999999999999985380680380635051100642567\
94264174386914539123932192756267*10^-41, \
-1.0149999999999999999998897499999999999999999853806803806350511006174\
62009746382736692535387904947180*10^-43, \
-1.0149999999999999999999889749999999999999999998538068038063505110061\
49514164568466234472485086767530*10^-45, \
-1.0149999999999999999999988974999999999999999999985380680380635051100\
61470035712789301212271980781307*10^-47, \
-1.0149999999999999999999998897499999999999999999999853806803806350511\
00614675251194997650990266937597*10^-49, \
-1.0149999999999999999999999889749999999999999999999998538068038063505\
11006146727406017081148770216506*10^-51, \
-1.0149999999999999999999999988974999999999999999999999985380680380635\
05110061467248954237916126569712*10^-53, \
-1.0149999999999999999999999998897499999999999999999999999853806803806\
35051100614672464436446265904565*10^-55, \
-1.0149999999999999999999999999889749999999999999999999999998538068038\
06350511006146724619258529763685*10^-57, \
-1.0149999999999999999999999999988974999999999999999999999999985380680\
38063505110061467246167479364741*10^-59, \
-1.0149999999999999999999999999998897499999999999999999999999999853806\
80380635051100614672461649687715*10^-61, \
-1.0149999999999999999999999999999889749999999999999999999999999998538\
06803806350511006146724616471771*10^-63, \
-1.0149999999999999999999999999999988974999999999999999999999999999985\
38068038063505110061467246164693*10^-65, \
-1.0149999999999999999999999999999998897499999999999999999999999999999\
85380680380635051100614672461647*10^-67, \
-1.0149999999999999999999999999999999889749999999999999999999999999999\
99853806803806350511006146724616*10^-69, \
-1.0149999999999999999999999999999999988974999999999999999999999999999\
99998538068038063505110061467246*10^-71, \
-1.0149999999999999999999999999999999998897499999999999999999999999999\
99999985380680380635051100614672*10^-73, \
-1.0149999999999999999999999999999999999889749999999999999999999999999\
99999999853806803806350511006147*10^-75, \
-1.0149999999999999999999999999999999999988974999999999999999999999999\
99999999998538068038063505110061*10^-77, \
-1.0149999999999999999999999999999999999998897499999999999999999999999\
99999999999985380680380635051101*10^-79, \
-1.0149999999999999999999999999999999999999889749999999999999999999999\
99999999999999853806803806350511*10^-81, \
-1.0149999999999999999999999999999999999999988974999999999999999999999\
99999999999999998538068038063505*10^-83, \
-1.0149999999999999999999999999999999999999998897499999999999999999999\
99999999999999999985380680380635*10^-85, \
-1.0149999999999999999999999999999999999999999889749999999999999999999\
99999999999999999999853806803806*10^-87, \
-1.0149999999999999999999999999999999999999999988974999999999999999999\
99999999999999999999998538068038*10^-89, \
-1.0149999999999999999999999999999999999999999998897499999999999999999\
99999999999999999999999985380680*10^-91, \
-1.0149999999999999999999999999999999999999999999889749999999999999999\
99999999999999999999999999853807*10^-93, \
-1.0149999999999999999999999999999999999999999999988974999999999999999\
99999999999999999999999999998538*10^-95, \
-1.0149999999999999999999999999999999999999999999998897499999999999999\
99999999999999999999999999999985*10^-97}

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.

his answer

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

July 9, 2022

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 of MRB constant (CMRB) computations:

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.

11/27/2022

Using only 8 kernels of i9-13900K128 GB 5200MHZ RAM, only 8 kernels of i9-12900KS 64 GB 4800 MHz and only 8 kernels of i9-12900K 128 GB 5200MHZ RAM on the Wolfram Lightweight Grid, I calculated 100,493 digits of CMRB in 626.7164761s (less than 10.5 min) absolute time! And a computation time from the Timing[] command of 201.016 s (3.35 min). See the notebook here.

It ends with

131072 iterations done in 626.7 seconds. Should take 0.007341 days or 634.3s, finish Sun 27 Nov 2022 14:22:31.

Finished on Sun 27 Nov 2022 14:22:24. Processor time was 201.016 s.

Actual time was 626.7164761

Enter MRBtest2 to print 100493 digits

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

11/16/2022

I've found ways of tweaking out new records with my computers. Here 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. However, with my new i9-13900K, this Timing[..] has led to a new problem! Timing[..] does not work well with the 9-13900K's 16 efficiency cores. Naturally, I got around that issue by doing single core operations for m2 computations. Also, computations of only a few digits of CMRB have small errors (I presume). Using the Wolfram Lightweight Grid, the 300,000-digit computation used 8 cores from the I-12900KS for efficiency.

enter image description here

This is the fairest comparison of my fastest computer's timing in calculating digits of CMRB: enter image description here

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

The i9-12900KS column is documented here.

The i9-13900KS column is documented here.

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

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

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

 Out[72]= 0.*10^-301494
POSTED BY: Marvin Ray Burns

If, above this, if you see the phrase, "Try to beat these MRB constant records!" you will need to refresh the page in order to see the first three posts.

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

These results are from the Timing[] command:

M2 table

The i9-12900KS column is documented here.

The 2022 i9-13900K column documentation:

The 2023 i9-13900K column documentation in this link

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

[5]: https://www.wolframcloud.com/obj/bmmmburns/Published/late 2022 MKB(1).nb

POSTED BY: Marvin Ray Burns

If, above this, you don't see the data ""Absolute time" 185.491 days" you'll need to refresh the page to see the MRB constant records.

§0. Wolfram+AI is the quintessential team evaluating the MRB constant.

partner

(CC)

Rhapsody in MRB by GPT

AI generated slide show with poetry.

Read aloud by Marvin Ray Burns

here enter image description here

```




The MRB constant CMRB equals enter image description here.

Bard AI pointed out a connection from Riemann Hypothesis to CMRB.

enter image description here

**In conclusion, the MRB constant and the Riemann hypothesis are two related but distinct concepts. The MRB constant is a mathematical constant that is defined in terms of the prime number distribution. The Riemann hypothesis is a conjecture about the distribution of the prime numbers. If the Riemann hypothesis is true, then it would have implications for the MRB constant. However, it is also possible that the Riemann hypothesis is false. If this is the case, then it would not be possible to say anything about the MRB constant based on the Riemann hypothesis. **


enter image description here

Example

Then concerning the whole series GPT 4 said, enter image description here



enter image description here FACTS Explain

CMRB

MTHWLD IMG MTWLD TXT


starting Ok. Here: BingAI should have said, 2^(1/2) - 1 = 0.4142135.

Instead, it calculated (1/2)^(1/2) - 1 = -1 + 1/Sqrt[2]=-0.292893 .


A haiku


Compare GPT with Bing in recognizing the MRB constant. CHAT Bing


Compare GPT with Bing in writing Mathematica code.

: GPT GPT faster1 GPT faster2 It showed "N[MRB[100], 100]" GPT altsgns1 GPT altsgns2 GPT altsgns3

Now, it's Bing AI's turn. enter image description here enter image description here enter image description here

With just a little tweaking and a lot of automating, the program says, It takes around 10^(n+/-0.2) partial sums s for n digits.


After receiving Wikipedia's and MathWorld's articles on the MRB constant (the upper limit point of the sequence of the above partial sums), Google OpenAI Chat CPT described the constant as follows.

...

Burns: Write a Wikipedia article for the MRB constant.

I'm sorry, as an AI language model, I cannot create or modify articles on Wikipedia. However, I can provide a draft of an article on the MRB constant that you can use as a starting point:

Chat AI 2 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."

GPT4 MRB1 GPT4 MRB2 GPT4 MRB3

POSTED BY: Marvin Ray Burns

If, above this reply, you see the picture followed by the words Reply | Flag, \you will need to refresh the page in order to see that post written by AI..

"§A. Possibly the most epigrammatic closed forms for checking up to 10^10 digits of CMRB!"

Possibly the most epigrammatic closed forms used for checking up to 6,500,000 digits of CMRB!

(The proof of which remains elusive.)

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

Definition of epigrammatic as in concise marked by the use of few words to convey much information or meaning.

Q=MinkowskiQuestionMark;

Clearly, the rational values for n with even more digits could be used to check much larger approximations to CMRB:

POSTED BY: Marvin Ray Burns

If, above this, you don't see the mention of this §13, you will need to refresh the page in order to see the full description and history of the MRB constant.

§13.

MRB Constant Records,

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

It is not uncommon for researchers and mathematicians to compute large numbers of digits for mathematical constants or other mathematical quantities for various reasons. One reason might be to test and improve numerical algorithms for computing the value of the constant. Another reason might be to use the constant as a benchmark to test the performance of a computer or to compare the performance of different computers. Some people may also be interested in the mathematical properties of the constant, and computing a large number of digits can help to reveal patterns or other features of the constant that may not be apparent with fewer digits. Additionally, some people may simply find the process of calculating a large number of digits to be a challenging and rewarding intellectual pursuit. It seems that the MRB constant, also known as the CMRB constant, is a mathematical constant defined as the sum of the infinite series Sum[(-1)^k(k^(1/k)-1),{k,1,n}] and has a decimal expansion of 0.187859... The MRB constant has been calculated to various digits using various methods and computers. The previous record number of digits was 40,000, calculated in 2006 using a program written in Mathematica and run on a Windows desktop computer. It is not known whether the MRB constant is algebraic, transcendental, or irrational. The process of computing the MRB constant using various methods and devices, including computers and software such as Mathcad, Mathematica, and Sigma. You have calculated 6,500,000 digits of the MRB constant using a supercomputer, with a computation time of 72.526 days and an absolute time of 185.491 days. You have mentioned that the error from a 6,000,000 or more-digit calculation that used a different method is 0.*10^-6029992.

When asked how, in detail, to calculate the digits of the MRB constant:

To calculate the digits of the MRB constant in more detail, you can use the following steps:

Write a program or use an existing software tool that can calculate the partial sums of the series (-1)^k k^(1/k) for a given value of n.

Use this program or tool to calculate the partial sums for a large value of n, such as n = 10,000 or n = 100,000.

Repeat step 2 for increasing values of n until the partial sums converge to a constant value. The more digits of accuracy you want, the larger n you will need to use.

The digits of the MRB constant are the digits of the converged value obtained in step 3.

It is important to note that calculating the digits of the MRB constant is a computationally intensive task that requires a fast computer and a good implementation of the algorithms for calculating the partial sums of the series (-1)^k k^(1/k). In addition, it is not known whether the MRB constant is algebraic, transcendental, or even irrational, so it may not be possible to calculate all of its digits. \

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

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

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

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

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

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

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

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

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

1 digit of the

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


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

enter image description here

enter image description here

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

Blockquote


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

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

enter image description here Sigma still can be found here.


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

enter image description here PII

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

documentation here


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

PIII

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

documentation here


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

enter image description here


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

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

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

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

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

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


100,000 digits of CMRB on Aug 12, 2007, at 8:00 PM EST, were computed in 170 hours on a 2.66 GHz Core 2 Duo using 64-bit Windows XP. The max memory used was 11.3 GB of RAM. The typical daily record of memory used was 8.5 GB of RAM.
To beat that, on the 4th of July, 2022, the same digits in  1/4 of an hour. ![CTRL+f][20]  "4th of July, 2022" for documentation.
To beat that, on the 7th of July, 2022, the same digits in  1/5 of an hour. ![CTRL+f][21]  "7th of July, 2022" for documentation (850 times as fast as the first 100,000 run!)

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

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

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

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

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

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

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

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

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

enter image description here


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

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

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

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

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

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

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

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

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

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



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

36.7 hours million notebook

30.5 hours million


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

for details.


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

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

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

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


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

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

 Gives

  {25.5469,0.*10^-9999984}

  {101.359,0.*10^-9999984}




  More information is available upon request.

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

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

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

enter image description here


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

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

Successful code was:

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

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

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

enter image description here

The MRB constant supercomputer replied,

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

"Computation time" 72.526 days.

 "Absolute time" 185.491 days.

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

It was checked in 6.9 hours: CTRL+f "Where MRB 1 is my record 6,500,000 digit computation of MRB constant digits, I found out that"


Next is "§0. Wolfram+AI is the quintessential team evaluating the MRB constant." Else refresh.






POSTED BY: Marvin Ray Burns

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

§12. CMRB and its applications

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

From Wikipedia:

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

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

`

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

enter image description here

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

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

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

enter image description here

Code:

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

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

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

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

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

From MathWorld:

MathWorld MRB MathWorld MRB 2

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

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

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

http://www.marvinrayburns.com/UniversalTOC25.pdf.

Crandall, R. E. "The MRB Constant." §7.5 in Algorithmic Reflections: Selected Works. PSI Press, pp. 28-29, 2012b.

Finch, S. R. Mathematical Constants. Cambridge, England: Cambridge University Press, p. 450, 2003.

Plouffe, S. "MRB Constant." http://pi.lacim.uqam.ca/piDATA/mrburns.txt.

Sloane, N. J. A. Sequences A037077 in "The On-Line Encyclopedia of Integer Sequences."

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

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


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

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

enter image description here

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

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

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

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

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

enter image description here enter image description here





Real-World, and beyond, Applications

CMRB as a Growth Model

Its factor a 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, as in Plot 1A," because enter image description here

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

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

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

By entering

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

we see, for Pt=p0e^rt, t>e

gives an effect of continuous decay of enter image description here 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

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

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 is closely related to geometric series: enter image description here

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,

enter image description here

...

enter image description here

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

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

CMRB can be written in geometric series form:

CMRB= enter image description here

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

enter image description here enter image description here

see notebook here.


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 in Wikipedia). However, the following is a little different.

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

As in Diagram 2, we give each n-cube a hyperbolic volume (content) equal to its dimension,enter image description here 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

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

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

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

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

enter image description here

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

enter image description here

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

enter image description here

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

enter image description here

Next







MeijerG Representation

From its integrated analog, I found a MeijerG 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

See notebook in this link.

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

enter image description here

f(n)=enter image description here.

`

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

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

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

=enter image description here

=enter image description here

=enter image description here

=enter image description here

=enter image description here

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

enter image description here

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


3/25/2022

Formula (11) =

enter image description here

As Matheamatica says:

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

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

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

Expanding the E^log term gives

enter image description here

which is enter image description here,

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


2/21/2022

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

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

Out[276]= 0.187859642462067

In

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

Out[278]= 0.187859642462067

Likewise, enter image description here

Expanding the exponents,

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

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

CMRB= enter image description here

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

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

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

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



12/29/2021

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

Mathematica knows that because

  m = N[NSum[-E^(I*Pi*t) + E^(I*Pi*t)*t^t^(-1), {t, 1, Infinity}, 
      Method -> "AlternatingSigns", WorkingPrecision -> 27], 18];
  Print[{m - 
     N[NIntegrate[
       Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(I \[Pi] t) - 
            E^(-I \[Pi] t))] I, {t, 1, -Infinity I}, 
       WorkingPrecision -> 20], 18], 
    m - N[NIntegrate[
       Im[(E^(Log[t]/t) + E^(Log[t]/t))/(E^(-I \[Pi] t) - 
            E^(I \[Pi] t))] I, {t, 1, Infinity I}, 
       WorkingPrecision -> 20], 18], 
    m + 2 I*NIntegrate[
       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, which defines the "integrated analog of CMRB" (MKB) described by Richard Mathar in https://arxiv.org/abs/0912.3844. (He called it M1.)

Like how this:

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

converges to

0.070776039311528802981 - 0.68400038943793212890 I.

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



11/14/2021

Here is a standard notation for the above mentioned

CMRB,enter image description here enter image description here.

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

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

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

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

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

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


11/01/2021

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

a ≠b enter image description here enter image description here

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

Thus, we find

enter image description here

here, and enter image description here next:

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

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

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

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

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



On 10/18/2021

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

CMRB= -complex infinity to +complex infinity

You can see it worked in this link here.

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

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

Out[3]= {0.18785964246206712025, 0.18785964246206712025}

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

Out[5]= {0.18785964246206712025, 0.18785964246206712025}

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

Out[7]= {0.18785964246206712025, 0.18785964246206712025}

Therefore, bringing

enter image description here

back to mind, we joyfully find,

CMRB n and 1

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

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

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

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

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

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

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

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

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

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

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


On 9/29/2021

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

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

CMRB integers 1

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

CMRB integers 2

See

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

Out[1]= 0.086374

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

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

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

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

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

Out[4]= -0.00602661

In[5]:= Head[mt]

Out[5]= Rational

Compared to the NSum formula for m, we see

In[6]:= Head[m]

Out[6]= Real


On 9/19/2021

I found the following quality of CMRB.

replace constants for CMRB



On 9/5/2021

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

strange

See proof in this link here.



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

I added a new MRB constant integral.

CMRB = integral to sum

We see many more integrals for CMRB.

We can expand 1/x into the following.

xx = 25.656654035

xx = 25.65665403510586285599072933607445153794770546058072048626118194\
90097321718621288009944007124739159792146480733342667`100.;


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

 (*
0.18785964246206712024851793405427323005590309490013878617200468408947\
72315646602137032966544331074969.*)

Expanding upon the previously mentioned

enMRB sinh

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

Let

x= 25.656654035105862855990729 ...

along with the following constants (approximate values given)

{u = -3.20528124009334715662802858},

{u = -1.975955817063408761652299},

{u = -1.028853359952178482391753},

{u = 0.0233205964164237996087020},

{u = 1.0288510656792879404912390},

{u = 1.9759300365560440110320579},

{u = 3.3776887945654916860102506},

{u = 4.2186640662797203304551583} or

$ u = \infty .$

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

See this notebook from the wolfram cloud for justification.



2020 and before:

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

CMRB =enter image description here

Furthermore, as enter image description here,

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



In the light of the parts above, where

CMRB

= k^(1/k)-1

= eta'(k)

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

eta *z^k






Primary Proof 1

CMRB=enter image description here, based on

CMRB eta equals enter image description here

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

Dark Marthorp's proof



Primary Proof 2

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

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

n^(1/n)-1

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

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

argument 1 argument 2



Primary Proof 3

Here is proof of a faster converging integral for its integrated analog (The MKB constant) by Ariel Gershon.

g(x)=x^(1/x), M1=hypothesis

Which is the same as

enter image description here because changing the upper limit to 2N + 1 increases MI by 2i/?.

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

Iimofg->1

Cauchy's Integral Theorem

Lim surface h gamma r=0

Lim surface h beta r=0

limit to 2n-1

limit to 2n-

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

leftright

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

enter image description here





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

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

CMRB(1-i)

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

gives

6.10377910^-23 - 6.10377910^-23 I.

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

enter image description here






Update 2015

Here is my mini-cluster of the fastest 3 computers (the MRB constant supercomputer 0) mentioned below: The one to the left is my custom-built extreme edition 6 core and later with an 8 core 3.4 GHz Xeon processor with 64 GB 1666 MHz RAM.. The one in the center is my fast little 4-core Asus with 2400 MHz RAM. Then the one on the right is my fastest -- a Digital Storm 6 core overclocked to 4.7 GHz on all cores and with 3000 MHz RAM.

first 3 way cluster

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

Likewise, Wolfram Alpha here says

enter image description here

It also adds

enter image description here

Interestingly,

enter image description here

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

The next reply should say "

§13.

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

POSTED BY: Marvin Ray Burns

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

§10.

How it all began

From these meager beginnings:

This person's life experience demonstrates that academic grades in school may not accurately predict success in mathematics. Their report cards show poor grades in the subject. However, when given a self-paced program, the person discovered a newfound interest in math in junior high. In 7th grade in 1975-1976, he independently proved Tic-tac-toe is a solved game, meaning that a game that is played optimally by both players will always result in a tie. Their grades improved with the opportunity to explore as they researched and studied math and chess and other games more. enter image description here That's him entranced by chess for the first time, before joining the Thomas Carr Howe Chess club, where he helped them win the state championship!

After nearly a lifetime they returned to pursue their passion for math, writing out powers of 2 and creating algebra problems for themselves to solve. They even purchased introductory calculus books. This one was the first: enter image description here Despite caring for their mother with Alzheimer's and working long hours, they attended university classes to further their knowledge. They are now listed on Wikipedia as an amateur mathematician and have studied graduate-level topics in mathematics. The reason for their slow start and eventual success is unclear and could be attributed to factors such as the educational system and psychology. However, their belief in their ability to learn and succeed in math played a crucial role in their achievements.


From these meager beginnings:

Inspired by Steven R Finch's historic essays on mathematical constants such as the one that starts out below, enter image description here

On January 11 and 23,1999, this researcher wrote,

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

The point is that the author found the MRB constant (CMRB), meaning after all the giants were through roaming the forest of numbers and founding all they found, one virgin mustard seedling caught their eye. So, this writer carefully "brought it up" to a level of maturity and my understanding of math along with it! (In another reality, they invented CMRB and then discovered many of its qualities.)

In doing so found out that this constant (CMRB)

MRB math world snippet

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

was more closely related to other constants than could have been imagined.

As the apprentice of all, building upon the foundation of Chebyshev (1854–1859) on the best uniform approximation of functions, as vowed on January 23, 1999. "I took CMRB apart and examined it 'bit by bit,' finding connections to all kinds of arithmetical manipulations." Not satisfied with all too convenient constructs (half-hazardously put together formulas) that a naïve use of numeric search engines like Wolfram Alpha or the OEIS might give, this researcher set out to determine the most interesting (by being the most improbable but true) approximations for each constant in relation to it.

For example, we have a strong arithmetic relationship with the Lemniscate Constant:

According to Wikipedia

In mathematics, the lemniscate constant ϖ is a transcendental mathematical constant that is the ratio of the perimeter of Bernoulli's lemniscate to its diameter, analogous to the definition of π for the circle.


Next, consider its relationship to Liouville's (L) and the Euler Gamma constant ( $\gamma$}.


Consider its relationship to Viswanath's constant (VC)

Viswanath' math world snippit

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

With both being functions of x1/x alone, ** we have these near-zeors of VC using C*MRB*, which have a ratio of Gelfond's constant $=e^\pi.$

=e^\pi


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

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

enter image description here



What about "?" for m= the MRB constant? We get over 7,000 digits of precision with hardly no effort at all!

enter image description here





From these meager beginnings:

On Feb 22, 2009, this researcher wrote,

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

enter image description here

Come to find out this discovery, a very slow-to-converge oscillatory integral, would later be further defined by Google Scholar.

Here is proof of a faster converging integral for its integrated analog (The MKB constant) by Ariel Gershon.

g(x)=x^(1/x), M1=hypothesis

Which is the same as

enter image description here because changing the upper limit to 2N + 1 increases MI by $2i/\pi.$

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

Iimofg->1

Cauchy's Integral Theorem

Lim surface h gamma r=0

Lim surface h beta r=0

limit to 2n-1

limit to 2n-

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

leftright

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

enter image description here

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

enter image description here

M1 has a convergent series, enter image description here which has lines of symmetry across whole-and-half number points on the x-axis, and half-periods of exactly 1, for both real and imaginary parts as in the following plots.

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

big plot small plot

Also where

Then

f[x_] = Exp[I Pi x] (x^(1/x) - 1); Assuming[
 x \[Element] Integers && x > 1, 
 FullSimplify[Re[f[x + 1/2]] - Im[f[x]]]]

gives 0


M2 and CMRB are connected:


In the complex plane, they even converge at the same rate.

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

Here is a heuristic explanation for the observed behavior.

Write the integral as an infinite series,... for each additional term.

The integrand is a quotient with numerator... This implies:

o$

Consequently

I used the fact that enter image description here

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

Whileenter image description here enter image description here

enter image description here


A lot more theory behind it and ways of computing many more digits in this linked Wolfram Community post.



From these meager beginnings:

In October 2016, this researcher wrote the following here in ResearchGate:

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

ratio of a-1 to a,

the limit of the ratio of a to a - 1, as a goes to infinity, is Gelfond's Constant, (e ^ pi). We will consider the hypothesis and provide hints for proof using L’ Hospital’s Rule (since we have indeterminate forms as a goes to infinity):

The following should help in proving the hypothesis:

Cos[PiIx] == Cosh[Pix], Sin[PiIx] == I Sin-h[Pix], and Limit[x^(1/x),x->Infinity]==1.

Using L’Hospital’s Rule, we have the following:

L’ Hospital’s a's

(17) (PDF) Gelfond's Constant using MKB-constant-like integrals. Available from: https://www.researchgate.net/publication/309187705Gelfond%27sConstantusingMKBconstantlikeintegrals [accessed Aug 16 2022].

We find no limit "a" goes to infinity of the ratio of the previous forms of integrals when the "I" is left out, and we give a small proof for their divergence.

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

enter image description here


From these meager beginnings:

In November 2013, his researcher wrote:

$C$MRB is approximately 0.1878596424620671202485179340542732. See this and this.

formally vs extend ended enter image description here

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

To see this for yourself in Mathematica enter FindRoot[NSum[(-1)^n*(n^(1/n) - x), {n, 1, Infinity}], {x, 1}] where regularization is used so that the sum that formally diverges returns a result that can be interpreted as evaluation of the analytic extension of the series.

enter image description here

See here.

Also,

enter image description here




§11.

Scholarly works about CMRB.

From these meager beginnings:

In 2015 his researcher wrote:

Mathematica makes some attempts to project hyper-dimensions onto 2-space with the Hypercube command. Likewise, some attempts at tying them to our universe are mentioned at https://bctp.berkeley.edu/extraD.html . The MRB constant from infinite-dimensional space is described at http://marvinrayburns.com/ThegeometryV12.pdf. It is my theory that like the MRB constant, the universe, under inflation, started in an infinite number of space dimensions. They almost all instantly collapsed, leaving all but the few we enjoy today.

This is not the first time for one to think the universe consists of an infinitude of dimensions. Some string theories and theorists propose it too. Michele Nardelli added a vast amount of string theory analysis and its connection to dimensions and the MRB constant.

He said,

In the following links, there are several works concerning various sectors of Theoretical Physics, Cosmology, and Applied Mathematics, in which MRB Constant is used as a "regularizer" or "normalizer". This constant allows to obtain a better approximation to the solutions obtained, developing the various equations that are analyzed. The solutions in turn, lead to four numbers that are called "recurring numbers". They are zeta (2) = Pi^2/6, 1729 (Hardy-Ramanujan number), 4096 (which multiplied by 2 gives the gauge group SO (8192)) and the Golden Ratio 1.61803398 ...

HE HAS PUBLISHED HUNDREDS OF PAPERS ON STRING THEORY AND THE MRB CONSTANT!

https://www.academia.edu/search?q=MRB%20constant https://www.researchgate.net/profile/Michele-Nardelli

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

enter image description here

in this linked well-sourced and equally greatly cited Google Scholar promoted paper. Also here.

Dr. Richard J. Mathar wrote on the MRB constant here.

Xun Zhou, School of Water Resources and Environment, China University of Geosciences (Beijing), wrote the following in "on Some Series and Mathematic Constants Arising in Radioactive Decay" for the Journal of Mathematics Research, 2019.

A divergent infinite series may also lead to mathematical constants if its partial sum is bounded. The Marvin Ray Burns’ (MRB) constant is the upper bounded value of the partial sum of the divergent and alternating infinite series: -11/1+21/2-31/3+41/4-51/5+61/6-···=0.187859···(M. Chen, & S. Chen, 2016). Thus, construction of new infinite series has the possibility of leading to new mathematical constants.


enter image description here



If the next reply does not start with "§12. CMRB and its applications" you'll need to refresh the page to see it.


POSTED BY: Marvin Ray Burns

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

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

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

POSTED BY: Marvin Ray Burns

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

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

enter image description hereenter image description hereenter image description here

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

enter image description hereenter image description hereenter image description here

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

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

enter image description here

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

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

enter image description here

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