07/17/2008, 10:43 AM

Code:

`- Approaches to tetration`

We may classify the approaches to tetration in two classes: a "binary operator

approach" and an "iterative series approach"

-- the operator approach ----------------------------------

Here one tries to extend the hierarchy of binary operator

a+b : addition a*b : multiplication a^b : exponentiation a^^b : tetration

in a meaningful way

Extensions of this are made in two ways

assigning an index to the operation and to evolve this

to higher or lesser indices

a[0]b : "zeration" a[1]b : addition a[2]b : multiplication

a[3]b : exponentiation a[4]b : tetration a[5]b : pentation

...

[see links]

* Ackermann-function

Closely related is the concept of the Ackermann-function

A(a,index,iterate)

[see: Ackermann-function, <literature>]

* Reihenalgebra

Even an approach to extend this operator-hierarchy to fractional indices is known

where the index was adapted:

a[1]x : "do nothing"

a[2]x : add one to a a[1/2]b : subtract one // unary operator

a[3]b : addition a[1/3]b : subtraction

a[4]b : multiplication a[1/4]b : division

a[5]b : exponentiation a[1/5,subscript]b : inverses root or logarithm

a[6]b : tetration a[1/6,subscript]b : inverses depending on evaluation-precedence

...

The author tried then to find meaningful interpolations for this indexing scheme.

[markus Müller, Reihenalgebra]

-- the iterative series approach -----------------------------------------

Here operations/functions are expressed as series; for instance the operation

of exponentiation as powerseries, such that

exp(x) = 1 + x + x^2/2 + ...

and then iteration

exp°2(x) = exp(exp(x)) = 1 + exp(x) + exp(x)^2/2! + ...

= K + Ax + Bx^2 + Cx^3 + ...

--- powerseries

The most common approach, see for instance []

b^x = 1 + log(b)x + log(b)^2 x^2/2! +...

(b,x)°1 = b^x

(b,x)°2 = b^(b^x) = 1 + log(b)b^x + log(b)^2 b^2x/2! + ...

(b,x)°h = (b,b^x)°(h-1)

The needed manipulations on powerseries are sometimes explicitely

expressed in matrix-notation [see links]

---functions defined by general series ( dirichlet-like series,..)

The needed calculations are performed using derivatives of the functions

in the places where for powerseries we use their coefficients

[see Bell-matrix, Carleman-matrix]

--- series on integer iterates of the function itself

(b,x)°h = A x + B*(b,x)°1 + C*(b,x)°2 + ...

[for instance see : binomial expansion]

The iterative series approach implies also a different view: one assumes

an "initial-value" x, to which the operation is applied iteration-times

which then gives a final value.

So in

(b,x)°h we have a ternary operation where we apply the exponentiation

using base b h-times to the initial-value x.

This paradigm is followed in [see: dynamical systems, iteration theory, ... ]

The reverse-engineering of this paradigm leads then to the redefinition of

the common "binary operators" using the iteration-form (we use a local,

one-way notation here)

b occurs h times

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

(+,b,x)°h : x + b + b + ... b : iterated addition

(+,b,x)°-h : x - b - b - ... b : iterated subtraction

(*,b,x)°h : x * b * b * ... b : iterated multiplication

(*,b,x)°-h : x / b / b / ... b : iterated division

(^,b,x)°h : b^ b ^ ... b^x : iterated exponentiation, right associative

(^,b,x)°-h : Log_b(Log_b(...Log_b(x)))

Though for iterated addition and multiplication no powerseries is required,

they may be consistently expressed the same way using matrix-operators on

formal powerseries, which perform addition, multiplication and exponentiation

in the ring of formal powerseries according to this scheme [see link]

The latter form of notation (or some convenient adaptions [see "notations"])

like exp_b°h(x) for (^,b,x)°h allows then to write the iteration-scheme

for any function, for instance

(dxp,b,x)°h = dxp_b°h(x) : where dxp_b(x):= b^x - 1

(sin,b,x)°h = sin_b°h(x) : where sin_b(x):= i*(b^(ix) - b^(-ix))/2

--- Connection between series-iteration and operator paradigms ------------

The common binary operators can then be seen as reduced forms

of the series-iteration approach

a + b == (+,b,a)°1

a + b + b

= a + 2*b == (+,b,a)°2

a - b == (+,b,a)°-1

b - b = 0 == (+,b,b)°-1

b + b = 2*b == (+,b,b)°1 = (+,b,(+,b,b)°-1))°2 = (+,b,0)°2

== (*,b,2)°1

a * b == (*,b,a)°1

a * b * b

= a*b^2 == (+,b,a)°2

a / b == (*,b,a)°-1

b / b = 1 == (*,b,b)°-1

b * b == (*,b,b)°1 = (*,b,(*,b,b)°-1))°2 = (*,b,1)°2

== (^,b,2)°1

b ^ a == (^,b,a)°1

b ^(b ^ a) == (^,b,a)°2

log_b(a) == (^,b,a)°-1

log_b(b) = 1 == (^,b,b)°-1

b ^ b == (^,b,b)°1 = (^,b,(^,b,b)°-1))°2 = (^,b,1)°2