Matrix Operator Method

[Gottfried]

So the finding is that though the matrix multiplication of the T's is infinite, the result is expressible in finite terms (polynomials) of \( \text{log}(b) \)?

Exactly. The occuring infinite sums are decomposable into sums of simple exponential-series for which then exact values are defined (and computable to arbitrary precision). The compositions of the evaluated exponentials contain then only finitely many terms. See the display of the matrix T^2. I found these by studying the dot-products of the rows and second column of T*T which was then easily generalizable to the other columns of the matrix-product.

That would be useful to compare. Can you derive a recurrence from your matrix formula?

Yes. For this I see another streamlining of the formula first:
Note, that T = U * P~ , which can also be seen by the operation

Code:

´
  V(x)~ * T = V(b^x)~
  V(x)~ * U = V(b^x -1)~
  also: V(b^x -1)~ * P~ = V(b^x)~
  thus: V(x)~ * (U * P~ ) = V(b^x)~
  ==> U * P~  = T

A further adaption can be made. We have, that the final term in T^2 = U*dV(b^^0) * T*dV(b^^1) is

Code:

´
  T*dV(b^^1) = U *P~ * dV(b^^1)

We can rewrite this in terms of a power of P ( use notation "PPow()" ) by expanding with the trivial product dV(b^^1)*dV(1/b^^1)= I

Code:

´
  T*dV(b^^1) = U *    dV(b^^1)*dV(1/b^^1)   * P~ * dV(b^^1)
             = U * dV(b^^1)*  (dV(1/b^^1)   * P~ * dV(b^^1))
             = U * dV(b^^1)*            PPow(b^^1) ~

The general product-formula changes then to

Code:

´
  T^h =   prod_{k=0}^{h-1} (U * dV(b^^k))
       * PPow(b^^(h-1)) ~

and a recursion is then

Code:

´
  T^(h+1) = T^h    * PPow(-b^^(h-1))~ * U * dV(b^^h) * PPow(b^^h)~

or, even more simple

  T^(h+1) = T^h    * PPow(-b^^(h-1))~ * T * dV(b^^h)

where the first part of the product , T^h * PPow(-b^^(h-1))~ , gives a triangular matrix.

The recursion may also be seen "in action", when evaluated for a parameter x. We need an ascii notation for iterated exponentiation, I use x.b^^h for exp_b°h(x) here, or if x=1, simply b^^h .

We have by definition, that

Code:

'
  V(x)~ * T^(h+1) = V(x.b^^(h+1)) ~

Using the recursion-formula we get

Code:

'
  V(x)~ * T^(h+1) = V(x) ~*T^h  * PPow(-b^^(h-1))~ * T     * dV(b^^h)
                  = V(x.b^^h) ~ * PPow(-b^^(h-1))~ * T     * dV(b^^h)
                  =        V(x.b^^h - b^^(h-1))~   * T     * dV(b^^h)
                  =          V(b^(x.b^^h - b^^(h-1)))~     * dV(b^^h)
                  =          V(b^(x.b^^h)/b^(b^^(h-1)))~   * dV(b^^h)
                  =          V(x.b^^(h+1)/b^^h)~           * dV(b^^h)
                  =          V(x.b^^(h+1))~ * dV(1/b^^h)   * dV(b^^h)
                  =          V(x.b^^(h+1))~ *              I
                  =          V(x.b^^(h+1))~

which is the same result.