Notes on Andy's slog

In this note I'm proposing a method for an improvement for the computation of the slog. I've seen the thread "exact values for slog", but this exposition introduces then the need of a fixpoint, and in turn then the problem of complex series for bases b>eta. The idea which I propose here works with the original slog-matrix.

The problem with the slog-matrix as given in Andrew's papers is, that the resulting coefficients differ if the matrixsize is increased. Fortunately the values stabilize with increasing matrixsize and we can assume a convergence to the unknown values in the limit; but the unpredictability would be unsatisfactory for me.

If we introduce LU-decomposition of the slog-matrix, we have much better control over the characteristics of this change of values.

I'll reformulate Andrew's matrix-equation, which determines the slog-coefficients, a bit, to have it compatible with the usual Carleman-matrix-notation for exp().

Assume for a base b the (transposed) carleman-matrix Bb, such that

V(x)~ * Bb = V(b^x)~

then a simple reformulation of Andrew's definition for the slog-coefficients in a vector L is

I_0 = (Bb - I)*L

where I_0 is the first column of the identity matrix or simply[1,0,0,...], thus the solution were the first column of the inverse of (Bb - I) if that were invertible, and we had for the slog

V(x)~ * L = slog(x)

But because the first column in (Bb-I) is zero, such an inversion can't be made. Andrew's solution for this subproblem is, to use the top square submatrix when the empty column is removed. A nice consequence is that the first entry of L is then arbitrary in the solution and can be used for norming (It's set to -1 actually).

Let's call the so-constructed matrix B@. We don't have immediately the exact solution for the inverse in the infinite case, but may find a reasonable approximate by increasing the size nxn of B@ and observe, when the results converge to approximately constant values.

But this can be solved more elegantly using the LU-decomposition of the squarematrix B@.

Assume B@ = Q * R~ where Q and R are lower triangular. The entries of Q and R are constant if the size is changed, increasing size just appends rows and columns. The same is true for their inverses; we have

B@^-1 = R~ ^-1 * Q^-1 = RI~ * QI // give them names

The sought solution L is then

RI~ * QI * I_0 = RI~ * QI_0 = L@

just the matrixproduct of the inverse RI~ with the first column in the inverse QI and L is the concatenation

L = concat([-1], L@ )

This construction provides constant values in RI and QI for any dimension; the effect of the varying size is cought by the use of more or less columns in RI~ and rows in LI.

Thus we can compute RI and LI for a fixed size nxn, say n=64 and have the approximation of the coefficients in L by truncation of simple series instead of the untractable variability of matrix-entries which occurs by matrixinversion at varying sizes.

------------------

So far we have not yet new results, just a reformulation of the original problem. Chosing a certain size nxn gives the same answer as in the original solution of the problem.

However, we have now the entries of L as dotproducts of simple vectors, which have exact entries up to the selected size. Here "exact" means, they have the same value, which they would have in the case of infinite size.

I give the following table as an example. Assume the base b=exp(1) then we get for LI_0 (first column) and RI (columns from the second on)

such that for the k'th entry of L we have the dot-product of the first column with the k'th column. So L[0] is set due to norming to -1, L[1] is the dotproduct of the first and the second column, as many rows as the selected matrix-size indicates.

Here I give the terms of the dotproducts, meaning columns 2 to 7 of the above table (begin counting at 1) where the coefficients of column 1 are already multiplied in:

and to find the values for L based on a selected dimension n we have to compute the partial sums just up to the n'th row

and we see, how the coefficients approximate certain values with increasing n.

(compare this values with that at http://tetration.itgo.com/pdf/TetrationS..._28-32.pdf; at the derivatives given there you need division by the appropriate factorial, so the value 0.24915 here is related to 0.49870.. from D^2 for base e, n=60 there by division by 2! and so on)

Well, so far this gives at least a bit more control over the error-estimate.

Now for two modifications of evaluation.

I expected, that at this stage the convergence-acceleration using Euler-summation instead of simple partial sums would come into play. But the series seems to be not well suited for Euler-summation, so this idea fails here. (Maybe there is another method available).

The second possible modification is change of order of summation.

What we have is

and with L = concat([-1],L@) we had

So we can rewrite

Her QI_0 is only one column, and we could separate it into one column-vector of 1 and a diagonalvector

and arrive at a column-scaled version of RI~ (means also: rowscaled version of RI); let's call it SLOG (which is actually the matrix given in the second table above)

SLOG is upper-triangular; and still has exact entries, meaning: the entries would be the same, if everything were done with infinite dimension

Then the left multiplication gives exact values in a vector, too:

and the unavoidable error due to truncation to finite size occurs only in the final dot-product

is far better controllable and possibly reducible by some acceleration-procedure.

In this note I'm proposing a method for an improvement for the computation of the slog. I've seen the thread "exact values for slog", but this exposition introduces then the need of a fixpoint, and in turn then the problem of complex series for bases b>eta. The idea which I propose here works with the original slog-matrix.

The problem with the slog-matrix as given in Andrew's papers is, that the resulting coefficients differ if the matrixsize is increased. Fortunately the values stabilize with increasing matrixsize and we can assume a convergence to the unknown values in the limit; but the unpredictability would be unsatisfactory for me.

If we introduce LU-decomposition of the slog-matrix, we have much better control over the characteristics of this change of values.

I'll reformulate Andrew's matrix-equation, which determines the slog-coefficients, a bit, to have it compatible with the usual Carleman-matrix-notation for exp().

Assume for a base b the (transposed) carleman-matrix Bb, such that

V(x)~ * Bb = V(b^x)~

then a simple reformulation of Andrew's definition for the slog-coefficients in a vector L is

I_0 = (Bb - I)*L

where I_0 is the first column of the identity matrix or simply[1,0,0,...], thus the solution were the first column of the inverse of (Bb - I) if that were invertible, and we had for the slog

V(x)~ * L = slog(x)

But because the first column in (Bb-I) is zero, such an inversion can't be made. Andrew's solution for this subproblem is, to use the top square submatrix when the empty column is removed. A nice consequence is that the first entry of L is then arbitrary in the solution and can be used for norming (It's set to -1 actually).

Let's call the so-constructed matrix B@. We don't have immediately the exact solution for the inverse in the infinite case, but may find a reasonable approximate by increasing the size nxn of B@ and observe, when the results converge to approximately constant values.

But this can be solved more elegantly using the LU-decomposition of the squarematrix B@.

Assume B@ = Q * R~ where Q and R are lower triangular. The entries of Q and R are constant if the size is changed, increasing size just appends rows and columns. The same is true for their inverses; we have

B@^-1 = R~ ^-1 * Q^-1 = RI~ * QI // give them names

The sought solution L is then

RI~ * QI * I_0 = RI~ * QI_0 = L@

just the matrixproduct of the inverse RI~ with the first column in the inverse QI and L is the concatenation

L = concat([-1], L@ )

This construction provides constant values in RI and QI for any dimension; the effect of the varying size is cought by the use of more or less columns in RI~ and rows in LI.

Thus we can compute RI and LI for a fixed size nxn, say n=64 and have the approximation of the coefficients in L by truncation of simple series instead of the untractable variability of matrix-entries which occurs by matrixinversion at varying sizes.

------------------

So far we have not yet new results, just a reformulation of the original problem. Chosing a certain size nxn gives the same answer as in the original solution of the problem.

However, we have now the entries of L as dotproducts of simple vectors, which have exact entries up to the selected size. Here "exact" means, they have the same value, which they would have in the case of infinite size.

I give the following table as an example. Assume the base b=exp(1) then we get for LI_0 (first column) and RI (columns from the second on)

Code:

`´`

1.0000000 | 1.0000000 0 0 0 0 0

0.0 | -0.50000000 0.50000000 0 0 0 0

-0.50000000 | 0.15384615 -0.46153846 0.30769231 0 0 0

0.076923077 | 0.0 0.20000000 -0.40000000 0.20000000 0 0

0.27179487 | -0.020389669 -0.0054372451 0.22496602 -0.33167195 0.13253285 0

-0.086939284 | 0.00012042981 -0.035406365 -0.019047982 0.23230911 -0.26657139 0.088596200

-0.15299303 | 0.0069743952 0.0022932696 -0.046983888 -0.038118259 0.22566918 -0.20933515

0.077898378 | -0.00018812928 0.014141223 0.0085747395 -0.052251358 -0.057990267 0.20911611

0.085566478 | -0.0034592295 -0.0015275952 0.020752200 0.018548138 -0.050328489 -0.074882892

-0.063615701 | 0.00022812262 -0.0077001833 -0.0054463926 0.024338659 0.029821927 -0.042173652

-0.046087535 | 0.0021133242 0.0012705459 -0.012019852 -0.012043192 0.023457542 0.039689298

0.049178756 | -0.00025860250 0.0049910021 0.0041901657 -0.014532465 -0.019874732 0.018122626

0.022972558 | -0.0014743682 -0.0011845282 0.0080807452 0.0091994372 -0.013852550 -0.026895975

-0.036530832 | 0.00028774669 -0.0036160948 -0.0036252025 0.0098790317 0.015286734 -0.0096891402

such that for the k'th entry of L we have the dot-product of the first column with the k'th column. So L[0] is set due to norming to -1, L[1] is the dotproduct of the first and the second column, as many rows as the selected matrix-size indicates.

Here I give the terms of the dotproducts, meaning columns 2 to 7 of the above table (begin counting at 1) where the coefficients of column 1 are already multiplied in:

Code:

`´`

1.0000000 . . . . .

0.0 0.0 . . . .

-0.076923077 0.23076923 -0.15384615 . . .

0.0 0.015384615 -0.030769231 0.015384615 . .

-0.0055418075 -0.0014778153 0.061144610 -0.090146736 0.036021749 .

-0.000010470082 0.0030782041 0.0016560179 -0.020196788 0.023175526 -0.0077024902

-0.0010670339 -0.00035085428 0.0071882074 0.0058318281 -0.034525812 0.032026819

-0.000014654966 0.0011015784 0.00066795830 -0.0040702960 -0.0045173477 0.016289806

-0.00029599408 -0.00013071094 0.0017756926 0.0015870988 -0.0043064316 -0.0064074653

-0.000014512180 0.00048985255 0.00034647608 -0.0015483209 -0.0018971428 0.0026829064

-0.000097397906 -0.000058556330 0.00055396535 0.00055504102 -0.0010811003 -0.0018291819

-0.000012717749 0.00024545128 0.00020606714 -0.00071468858 -0.00097741460 0.00089124820

-0.000033870009 -0.000027211642 0.00018563539 0.00021133461 -0.00031822851 -0.00061786934

-0.000010511626 0.00013209895 0.00013243166 -0.00036088925 -0.00055843711 0.00035395235

Code:

`´`

1.0000000 . . . . .

1.0000000 0.0 . . . .

0.92307692 0.23076923 -0.15384615 . . .

0.92307692 0.24615385 -0.18461538 0.015384615 . .

0.91753512 0.24467603 -0.12347077 -0.074762121 0.036021749 .

0.91752465 0.24775423 -0.12181476 -0.094958908 0.059197275 -0.0077024902

0.91645761 0.24740338 -0.11462655 -0.089127080 0.024671463 0.024324329

0.91644296 0.24850496 -0.11395859 -0.093197376 0.020154115 0.040614135

0.91614696 0.24837425 -0.11218290 -0.091610277 0.015847684 0.034206669

0.91613245 0.24886410 -0.11183642 -0.093158598 0.013950541 0.036889576

0.91603505 0.24880554 -0.11128246 -0.092603557 0.012869441 0.035060394

0.91602233 0.24905100 -0.11107639 -0.093318246 0.011892026 0.035951642

0.91598846 0.24902378 -0.11089075 -0.093106911 0.011573797 0.035333773

0.91597795 0.24915588 -0.11075832 -0.093467801 0.011015360 0.035687725

(compare this values with that at http://tetration.itgo.com/pdf/TetrationS..._28-32.pdf; at the derivatives given there you need division by the appropriate factorial, so the value 0.24915 here is related to 0.49870.. from D^2 for base e, n=60 there by division by 2! and so on)

Well, so far this gives at least a bit more control over the error-estimate.

Now for two modifications of evaluation.

I expected, that at this stage the convergence-acceleration using Euler-summation instead of simple partial sums would come into play. But the series seems to be not well suited for Euler-summation, so this idea fails here. (Maybe there is another method available).

The second possible modification is change of order of summation.

What we have is

Code:

`´`

RI~ * QI_0 = L@

and with L = concat([-1],L@) we had

Code:

`´`

V(x)~ * L = slog(x)

So we can rewrite

Code:

`´`

-1 + x*V(x)~ * RI~ * QI_0 = slog(x) // where x*V(x)~ = [x,x^2,x^3,...]

Her QI_0 is only one column, and we could separate it into one column-vector of 1 and a diagonalvector

Code:

`´`

-1 + x*V(x)~ * RI~ * diag(QI_0) * V(1) = slog(x)

and arrive at a column-scaled version of RI~ (means also: rowscaled version of RI); let's call it SLOG (which is actually the matrix given in the second table above)

Code:

`´`

SLOG = RI ~ * diag(QI_0)

-1 + x*V(x)~ * SLOG * V(1) = slog(x)

SLOG is upper-triangular; and still has exact entries, meaning: the entries would be the same, if everything were done with infinite dimension

Then the left multiplication gives exact values in a vector, too:

Code:

`´`

x*V(x)~ * SLOG = SL(x) ~

and the unavoidable error due to truncation to finite size occurs only in the final dot-product

Code:

`´ `

-1 + SL(x)~ * V(1) = slog(x)

is far better controllable and possibly reducible by some acceleration-procedure.

Gottfried Helms, Kassel