Exponentiation a^b or raising to a power is the operation which iterates over multiplication. In this chapter the double star ** rather than the arrowhead ^ functions as the exponential operator.
The hardly extendible superscript notation a^b is regarded as a remnant of a past, now gone.

Next comes the true superpower with three stars *** which Goodstein called tetration (tetra = 4) counting index 1 for addition (here 0 stars).
Our three stars equals two ^^ arrowheads in Donald Knuth's 1976 up-arrow notation – where the operand b always counts repetitions of items a. And not to Ackermann's phi recursion – because Ackermann's own iterator b counts the number of in-between arrow operators instead.

The insight that * is a countable unit, dawns with the recognition that operators *.. can be expanded at will. Of the various names for this family of operations that have been suggested, Nick Bromer's superexponentiation is most instructive. But Bromer's term is verbally overweight, we'll use our superpowers instead.

In David Hilbert's "On the infinite" a functional (function that takes a function as an argument) is deemed necessary to define this, while it follows immediately from Hilbert's own formula, that an ordinary function does the trick. Perhaps Hilbert didn't like variables of a next recursive level n1 substituted as arguments in lower type n functions, but his roundabout definition cannot hide the fact that this follows immediately by =.

• F₀(a,b) = ab
• F_n1(a,1) = I(F_n,a,1) = a
• F_n1(a,b1) = I(F_n,a,b1)
            = F_n(a,I(F_n,a,b))
          = F_n(a,F_n1(a,b)) == F_n(a,..a.) {#b#}

Note that superpower star operations aren't really built upon powers, because exponentiation a**b is the 2nd true operation in the list. The initial operation ab of zero stars, which is empty and naturally resolved as addition, forms the start at c=0 of the superpower series, where c counts the number of stars and c=1 is multiplication.

From the initial superpower rule a*1 = a the next operations *.. are recursively == defined, so that every reduction train stops at a well defined initial case.
Follows the general superpower formula providing for an arbitrary number c of stars.

• a*^...1 {*#c1} = a*^...1 {*#c c>0} == a*1 = a
• a*^...11 {*#c1} = a*^...a {*#c}   so 11*^..11 == 1111
• a*^...b1 {*#c1} = a*^...(a*^...b) {*#c *#c1}
                == a*^.. ... {*#c a#b1}

Find instructions for calculating with numbers of superpower size in the subchapter on super-calculation.

§2.0.2. Primitive recursive functions

We'll first explain what recursion is and what primitive recursion, and how all superpowers a*..b can be created just by primitive recursion. This answers to the meta-mathematical need to classify a function according to the simplest means with which to generate it.

As an example we'll generate a primitive recursive function family Fac which is a bit special because we start with a function index -1 where 0 is more common. Fa is faster than star superpowers, by Fac(a,0) = a instead of a*..0 = 1 {*#c c>1} so that for example Fa2(a,1) = a+a×a

The inverse unit can signify both the negative index - = -1 and subtraction as in a- = a-1. The applied list markers are explained in section 4.0.5.
Family Fac could very well have used one rule Fa0(a,b) = ab for initialization. Then only two axioms would have sufficed to define Fa instead, which is one less than for superstar or arrow operations.

• Fa_-(a,0) = 1
• Fa_-(a,b) = Fa_-(a,b-)1 == 1... {#b1} = b1
• Fa_c(a,0) {c≥0} = a
• Fa₀(a,1) = Fa_-(a,Fa₀(a,0)) = Fa_-(a,a) = a1
• Fa₀(a,b) = Fa_-(a,Fa₀(a,b-)) == Fa_-(a,..a.) {#b#} = ab
• Fa₁(a,b) = Fa₀(a,Fa₁(a,b-)) == Fa₀(a,..a.) {#b#} = a*b1
• Fa₂(a,b) == Fa₁(a,..a.) {#b#} = (a**i)... {#b1 0_*}
• Fa_c(a,b) = Fa_c-(a,Fa_c(a,b-)) > a*^...b1 {*#c a>0 b>0 c>1}

The reason why Fa didn't make it as a defining algorithm for superpowers is that its properties are not so cool as those of multiplication, etc… Because a*b = b*a is commutative and Fa1(a1,b) = Fa1(b1,a) is not.
And although the virtues of exponentiation are distributive, with a minor adaptation using logarithms the powers can be rendered commutative with a**(log(b)*e/log(e)) where e is an arbitrary exponent or base.

§2.0.3. Ackermann's jump

Ackermann used a primitive recursive φ function (phi) as a prerequisite to construct the higher level ψ function in his 1928 article "On Hilbert's construction of the real numbers".
The Ack_ψ (ψ) function makes the jump from primitive recursion into the vast unknown.

The Ack_φ (φ) function is a superpower algorithm, it differs from star operations only with respect to the initial cases for operators c>2. After that it grows away slightly from superpowers, though Ack_φ never catches up with the upstart function family Fac which raised its initial case earlier at Fa1(a,0) = a

• Ack_φ(a,b,0) = ab = a+b
• Ack_φ(a,0,1) = 0
• Ack_φ(a,0,2) = 1
• Ack_φ(a,0,c) {c>11} = a (Ackermann's extra axiom)
• e.g. Ack_φ(a,1,11) = a
•      Ack_φ(a,b,11) = a**b = a^b
•      Ack_φ(a,1,111) = a**a
•      Ack_φ(a,b,111) = a***b1 = a^^(b+1)
• Ack_φ(a,b1,c1) = Ack_φ(a,Ack_φ(a,b,c1),c)

If you'd replace the 2nd and 3d rule by a single axiom Ack_φ(a,1,c) {0<c<3} = a the evaluation of all expressions of Ack_φ where b>0 will work out fine.

Compare the relative speed of the functions of superpowers from this chapter. The three of them are relatively close, with differing values of b, while arrows a^...b {^#c} increase a unit 1 of c faster than stars.

• a*^...b {*#c c>11} < Ack_φ(a,b,c) < Fa_c(a,b) {a>0 b>0}

We still owe you Ackermann's historical psi-function which gave rise to the concept of the Ackermann numbers. The whole Shakespearean purpose of Ackermann's Ack_ψ function was not to be primitive recursive, which succeeded gloriously. Yet there was no mention of any Big numbers in Ackermann's famous article.

• Ack_ψ(a) = Ack_φ(a,a,a)
• Ack_ψ(i) == { 1, 4, 3^7625597484987,
                4^^(4^^(4^^(4^^5+1)+1)+1), .. }
• ψ(4) = φ(4,4,4) = φ(4,φ(4,3,4),3) = φ(4,φ(4,φ(4,2,4),3),3)
       = φ(4,φ(4,φ(4,φ(4,4,3),3),3),3)
  where  φ(a,b,3) = φ(a,..φ(a,1,3).,2) {#b-#}
                  = φ(a,..a.,2) {#b#}
                  = a**... {a#b1} = a***b1 = a^^(b+1)

The complications in working out the structure of the 4th Ackermann number seems to show that his extra axiom is apart from being unnecessary also relatively unnatural. But this depends on our view of naturalness, which is tainted by Donald Knuth's up-arrow type of superpowers. How cumbersome we may feel about defining extra axioms is not a strong argument in this discussion, given the leaner physique of Fa with its meaner power operation Fa2, which is similar to the function Ack_φ(a,b,4) and just as unwieldy if translated to an expression with stars/arrows.
Anyhow, without the extra axiom the resulting φ' function has the same rules as the superpower stars of bigI. And an expression Ack_ψ'(4) reduces to 4^^^4 = 4^^4^^4^^4 straightforwardly (in our eyes ;-)