i cannot answer the question because I'm not sure what exactly it is. (Useful rule: state a clear question.)
Also I need to redefine a few things so as to provide this post with workable code, since your "code" is in an image rather than actual cut-and-paste form. (Useful rule: provide explicit code in the post when at all possible.)
The remarks below might shed some light on things. This is a combination of observation, speculation, and a bit of algebra.
First I'll define a parametrized formal infinite series. I do so in terms of the numeric function NSum with settings as in the original post.
ff[k_] :=
NSum[(-1)^n (n^(1/n) - k), {n, 1, Infinity},
Method -> "AlternatingSigns"]
Seems like it would not be useful since it generally does not converge as an infinite sum, but we'll see some interesting things. First note that f[1] does converge and indeed it is (as an exact sum) nothing other than the MRB constant which,as in the original post, we will call m. What can we say about f[0]? For one thing, we get an actual value rather than a divergence message.
ff[0]
(* Out[2]= -0.3121361511420659 *)
So let's see where this arises. First observe that if we take an even partial sum (partial sum of an even number of terms), it agrees with the same partial sum of f[1] because the 1's in that case will cancel. So even partial sums approach m. Odd partial sums agree with their f[1] counterparts except they are missing a final +1. Since those counterparts also approach m the odd partial sums of f[0] must approach m-1. What NSum has done above amounts to averaging these, so we get an approximation to (m+(m-1))/2, or m-1/2.
Suppose we instead do ff[n] for arbitrary n. The same reasoning indicates we might expect a numeric average of m with m+k-1. So ff[3] for example would be 1/2 (m + (m+2-1)), or m+1.
ff[3]
(* Out[4]= 1.187850718950632 *)
The values we thus expect for u=2*m-1 and its negative are thus, respectively, 1/2 (m + (m+(2*m-1)-1)), or 2*m-1, and 1/2 (m + (m-(2*m-1)-1)), or 0.
The iterations in the post start with 'f[m]` and follow a recurrence.
m =
0.187859642462067120248517934054273230055903094900138786172004684089\
`65.2738334914441;
NestList[ff, m, 10]
(* Out[15]= {0.\
187859642462067120248517934054273230055903094900138786172004684089, \
-0.218207152104263, -0.4212387721809707, -0.5227536936238744, \
-0.5735107100514898, -0.5988889961203241, -0.6115780280832264, \
-0.6179224885294068, -0.6210946909851037, -0.6226807783293771, \
-0.6234738150597883} *)
Seems like it might be converging. Why, and to what? We can use the same analysis as before. Even partial sums converge to m, odd ones to m+prevValue -1, and these get averaged. Thus our sequence has the form g[n+1]==(m-1/2)+g[n]/2. In the limit as n->Infinity we'll have g[Infinity]==(m-1/2)+g[Infinity]/2. This gives g[Infinity]==2*m-1 which is indeed the observed behavior. I should note that this does not depend on starting with m.
NestList[ff, Pi, 20]
(* Out[17]= {\[Pi], 1.258646426046056, 0.3171815532439953, \
-0.1535467627081991, -0.388908860477912, -0.5065888792685919, \
-0.5654283736213546, -0.5948478632786993, -0.6095574793489804, \
-0.6169122230054896, -0.6205895626447112, -0.6224282163699438, \
-0.6233475351854442, -0.6238071905696708, -0.6240370162500397, \
-0.6241519280843605, -0.6242093834985925, -0.6242381109542483, \
-0.6242524745563462, -0.6242596562945312, -0.6242632471321907} *)
A reasonable question, one, for which I have no answer, is whether these methods might give an accurate method for computing u and thus m. I do not know how well the averaging is done by NSum (strictly speaking, I do not know if it is done at all, it is only an empirical observation in these examples). So I cannot venture a guess as to how well the process might converge at high precision. One thing I can say is that, if it converges at all, then one might try starting at low precision and increasing gradually, since earlier iterations are only approximations anyway so there is no sense it spending too much time on them in the arithmetic and error assessments and corrections.
