Let's give expressions some names:
x+3 = x+1+1+1 // lvl 1
x*3 = x+x+x // lvl 2
x^3 = x*x*x // lvl 3
What would be the mathematical term / real name / topic for lvls after 3?
Like:
x (lvl 4 operation) 3 = x^x^x
x (lvl 5 operation) 3 = x(lvl 4 operation)x(lvl 4 operation)x
..
Thanks in advance.
P.S. Above are not programming codes/languages
Tetration is the next hyperoperator after exponentiation. The operator is noted as ↑↑ — or ^^ in ASCII — following Knuth's notation.
The next operation in the sequence is pentation, then hexation, heptation, octation, etc. Ackermann's three-argument function calculates these operations recursively.
╭────────┬────────────────┬─────────────┬───────────────────╮
│ Level │ Name │ Notation │ Ackermann (3-arg) │
╞════════╪════════════════╪═════════════╪═══════════════════╡
│ 1 │ Successor │ a++ (unary) │ φ(a, 1, 0) │
│ 2 │ Addition │ a+b │ φ(a, b, 0) │
│ 3 │ Multiplication │ a×b │ φ(a, b, 1) │
│ 4 │ Exponentiation │ a↑b │ φ(a, b, 2) │
│ 5 │ Pentation │ a↑↑b │ φ(a, b, 3) │
│ 6 │ Hexation │ a↑↑↑b │ φ(a, b, 4) │
│ 7 │ Heptation │ a↑↑↑↑b │ φ(a, b, 5) │
│ 8 │ Octation │ a↑↑↑↑↑b │ φ(a, b, 6) │
╰────────┴────────────────┴─────────────┴───────────────────╯
There aren't really any general operations beyond exponentiation (primarily due to a lack of need). One possible extension is tetration, which abbreviates a stack of exponents with the same value. In brief (using Knuth's up-arrow notation
a ^^ 1 = a
a ^^ n = a^(a^^(n-1))
= a ^ a ^ ... ^ a (n items)
Up-arrow notation can itself be stacked, with a^^^a being a stack of as a^^a high, a^^^^a a stack a^^^a high, etc. (The numbers created are comically large; read about Graham's number to find out just how large a number you can build.)
One way to make this a Haskell question is to set the challenge of implementing the Ackermann function (whichever version) in terms of the "paramorphism" for natural numbers, represented here via Integer, and no other form of recursion.
paraNat :: t -> ((Integer, t) -> t) -> Integer -> t
paraNat base step n | n > 0 = step (m, paraNat base step m) where m = n - 1
paraNat base step _ = base
It's a well known fact that "paramorphism" corresponds to "primitive recursion", and it's another well known fact that Ackermann's function is not in the class of "primitive recursive functions". And yet, the problem has a solution. The clue is that paraNat is polymorphic in its return type t, whereas the class of "primitive recurisve functions" fixes t to be the natural numbers.
(I realise it's a touch unorthodox to answer a question by posing a question, but I hope it's interesting anyway. I'll delete this answer if folk think it's problematic.)
