Marvin Ray Burns

 I've been using Maple since 1997 or so.

MaplePrimes Activity


These are replies submitted by Marvin Ray Burns

 

I computed 314159 digits. Documentation available upon request. It did take 59 GB of RAM!

 

 

 

marvinrayburns.com

Here is a very rough draft of a cloud document showing methods of computing the MRB constant in Maple. Does anyone care to help me improve it? I am looking for some help in the other acceleration methods and the Crandall Unified Method.

My improvements are mostly superficial but here is the latest version:

 

Computing the MRB constant in Maple

NULL

Marvin Ray Burns

Original investigator of the MRB constant

and others

``

Introduction

 

The MRB constant is related to the following divergent series:

sum((-1)^k*k^(1/k), k = 1 .. infinity)

Its partial sums

s[n] = sum((-1)^k*k^(1/k), k = 1 .. n)

are bounded so that their limit points form an interval  [-0.812140..,0.187859..] of length 1.   The upper limit point 0.187859.. is what is known as the MRB constant.

``

 

The MRB constant can be explicitly defined by the following infinite sums:

0.187859...=(∑)(-1)^(k)(k^(1/(k))-1)=(∑)((2 k^(1/(2 k))-(2 k-1)^(1/(2 k-1)))

 

The purpose of this document

 

To show how to effectively compute many digits of the MRB constant in Maple.

``

````

Computing the Constant through Brute Force

 

Only 2 corret decimal places of the MRB constant can be computed by the following command.  ;

b := -1; for a from 2 to 30000 do b := b+(-1)^a*a^(1/a) end do; print(evalf(b))

.188031377

(2.1)

It becomes obvious that brute force is not an effecient method for computing the MRB constant in Maple.;

``

``

Acceleration Methods

 

Levin's u-transform

 

With evalf(sum(f, x=a..infinity)) Levin's u-transform is used.

The following command gives 500 digits of the constant, albeit very slowly.

evalf(sum((-1)^n*(n^(1/n)-1), n = 1 .. infinity), 500)

.18785964246206712024851793405427323005590309490013878617200468408947723156466021370329665443310749690384234585625801906123137009475922663043892934889618412083733662608161360273812637937343528321255276396217148932170207628206217151671540841268044836354167199851976802527598938993914457983505561350964852107120784442309586812949768852694956420425558648367044104252795247106066609263397483410311578167864166891546003422225883800254553968929471142122189105098328712277308020036445215390536395055332203471

(3.1.1)

``

Cohen/Rodriguez/Zagier Acceleration Method as applied by Burns

 

The following procedure computes 500 digits of the constant much faster.;

A037077 := proc (e) local a, b, c, d, s, k, n, m; if e < 100 then n := 31+e; Digits := 31+e else n := 131*round((1/100)*e); Digits := 131*round((1/100)*e) end if; a := array(0 .. n-1); a[0] := 1; for m to n-1 do a[m] := ((1/2)*sinh(2*ln(m+1)/(m+1))+cosh(ln(m+1)/(m+1))^2-1)/sinh(ln(m+1)/(m+1)) end do; d := (1/2)*(3+2*2^(1/2))^n+(1/2)/(3+2*2^(1/2))^n; b := -1; c := -d; s := 0; for k from 0 to n-1 do c := b-c; b := 2*b*(k^2-n^2)/((2*k+1)*(k+1)); s := s+c*a[k] end do; Digits := e; print(evalf(1/2-s/d)) end proc

proc (e) local a, b, c, d, s, k, n, m; if e < 100 then n := 31+e; Digits := 31+e else n := 131*round((1/100)*e); Digits := 131*round((1/100)*e) end if; a := array(0 .. n-1); a[0] := 1; for m to n-1 do a[m] := ((1/2)*sinh(2*ln(m+1)/(m+1))+cosh(ln(m+1)/(m+1))^2-1)/sinh(ln(m+1)/(m+1)) end do; d := (1/2)*(3+2*2^(1/2))^n+(1/2)/(3+2*2^(1/2))^n; b := -1; c := -d; s := 0; for k from 0 to n-1 do c := b-c; b := 2*b*(k^2-n^2)/((2*k+1)*(k+1)); s := s+c*a[k] end do; Digits := e; print(evalf(1/2-s/d)) end proc

(3.2.1)

A037077(500)

.18785964246206712024851793405427323005590309490013878617200468408947723156466021370329665443310749690384234585625801906123137009475922663043892934889618412083733662608161360273812637937343528321255276396217148932170207628206217151671540841268044836354167199851976802527598938993914457983505561350964852107120784442309586812949768852694956420425558648367044104252795247106066609263397483410311578167864166891546003422225883800254553968929471142122189105098328712277308020036445215390536395055332214988

(3.2.2)

NULL

NULL

``

Other acceleration methods

 

``

``

Crandall Unified Method

 

http://www.perfscipress.com/papers/UniversalTOC25.pdf

NULL

``

``

 

Download B_computing_the_MRB_.mw

 Let "rationalizing~" be the process of approximating seemingly irrational numbers with rational ones and A/R be “digits of accuracy given in the result / digits of precision used in the computation.”  Greater A/R = better rational approximation. We will assume 3/16 and 355/113 are the convergents that have the biggest A/R of MRB and pi respectively. 3/16 has an A/R of 4/3 or 1.333…, and  355/113 has an A/R of 7/6 or 1.1666… Therefore, MRB is easier to rationalize~ than pi.

 

marvinrayburns.com

MRB^-1                        =5.323123...

e^x+Pi^x=2^3*3^4 | x=5.323110...

Here 13 digits of precision used in the computation give 15 digits of accuracy in the result:

MRB                     = 0.1878596424620671202...

876799/4667309 = 0.18785964246206968512...

I think this is beautiful:

16/3    =5.333...

MRB^-1=5.323...

16/3     =5.333333...

MRB^-1=5.323123...

244808503290991551947246013960021548/
1303145795885476704882046150940254855
 
is a rational approximation made up of 
73 digits giving 77 digits of accuracy to the MRB constant, 
but if it were as good as an approximation as 3/16, 
it would give at least 97 digits of accuracy.

I was under the impression that according to the simple continued fraction expansion there is no better rational approximation than 31/165 with 150,000 digits or less in the numerator. But that is not so.

I overlooked the simplier and best rational approximation (3/16) where three digits of precision give four digits of accuracy. (31/165) is five digits of precision giving only five digits of accuracy.

MRB=    0.187859...

Best approximations that I know

3/16=    0.1875

31/165=0.187878...

 

Actually, 3/16 < MRB < 31/165.

The above projections are still nowhere near right! I keep confusing the "length" that is represented by the MRB constant with the length of the edge of the n-cubes.

Here is a step by step two dimensional projection of the first 8 hypercubes lined up in such a way that it shows what happens as you compute approximations to the MRB constant. Whether the hypercubes are to scale or not it makes little difference because the series is so slow to converge that the first 8 terms give no decimal places of accuracy.The divergent series for the MRB constant is sum((-1)^n*(n^(1/n)),n=1..infinity) = -sum((-1)^(n+1)*(n^(1/n)),n=1..infinity) as shown here.

In case it helps anyone here are the first 7 n-cubes with the node labels removed and with transparent backgrounds.

 

The red seqment in the above mess is not in the right place neither should it be along the y-axis.

The following mess is a two dimensional projection of the segment, square, cube, tesseract, penteract and hexeract lined up not quite according to Diagram 3. The red segment should  represent 1-sqrt(2)+3^(1/3)+4^(1/4)-5^(1/5)+6^(1/6), but I'm not sure if I kept track of its possition altogether correctly.Furthermore, it is not necessarily to scale.

Here is the workseet the n-cubes came from. (I tried to erase the yellow and black colors.)

 

with(GraphTheory):

DrawGraph([H1, H2, H3, H4, H5, H6], style = spring, dimension = 2)

 

Download MRB_in_parts.mw

 

 

 

 

 

 

Digits:=20
Let c be the MRB constant.
Let V be the figure eight hyperbolic volume.
c := .1878596424620671202485179340542732300559030949001387
V := 2.0298832128193072500424051085490405
(15*(V+667))/(839*V+2605)  = 2.329452296051860367745
evalf(c+Pi-1)              = 2.329452296051860358712
Let p be the prime constant.
p := .4146825098511116602481096221543077083657742381379
(9509-169*p)/(50*(18*p+23)) = 6.196711067333514470392
evalf(c+7*(4-Pi))           = 6.19671106733351445101
 
Digits := 53
c := .187859642462067120248517934054273230055903094900138786172
evalf(17Pi-642614815285663014792765/12074864494484015995117-c) = -1.*10^(-51)
2 3 4 5 6 7 8 Last Page 4 of 21