diagonal vs natural

[bo198214]

I just realized that it is quite easy in maple to compute the matrix power via diagonalization (the function is called "MatrixPower" and you can put float values as exponents), I just compare it with the natural tetration.

To get the dsexp (diagonalization super exponential) I compute the Carlemann matrix of then just take the -th matrix power via "MatrixPower" and get the value of row 1 and column 0, which is then so the diagonalization tetration is .

For the comparison I compute which is always a periodic function with period 1.

And this is the resulting for matrix size of dsexp and nslog being 9 and precision 90 digits:
   
I think even in this low precision its recognizable that they are not equal. However I am currently preparing a plot in doubled precision which though takes some time, so I will add the graph later to this post.

edit: and here it is now:
   
hm, the amplitude decreased a lot, so I am again unsure ...

[bo198214]

Here are two plots with a different precisions for the nslog, i.e. matrix size 50 and exact fractional arithmetic. The precisions of dsexp is equal to those in the previous post
   
   
As the peak is roughly around 0.3 but will probably move to 0.2 as the matrix size of the matrix power approaches the matrix size of the natural abel function and the computation is very time consuming I continue only computing for







The first two arguments of are the precision (number of digits) and the matrix size. Note, that the value degenerates if the precision is too little. Each arithmetic operation in the computation of the matrix power introduces a small error which sum up in the overall computation of the matrix power.

Actually I think we can see that decreases with increasing precision and matrix size, though very slowly but continuously. So it rather seems that the diagonalization method and Andrew's method are the same in the limit case!

[bo198214]

However here are disillusioning news.
nslog is computed with the same matrix size as dsexp and I pushed up to 35, computing with precision 400 up to and computing with precision 800 for . Till everything looks nice:
   
But after we see that the difference probably does not converge to 0:
   

edit: indeed this behaviour continues, with some effort (the used memory easily exceeds 2GB) I computed (precision 800) which seems quite close to the real limit.