Hyper operators or hyperoperations are extensions to the standard binary operators addition, multiplication, and exponentiation, as well as the unary successor function. Multiplication is repeated addition, and exponentiation is repeated multiplication, so it is natural to extend them further — repeated exponentiation is called "tetration," for instance. When used on the positive integers, each hyper operator grows much faster than the previous one; since the numbers generated become very large, hyper operators are considered to be googological. Hyper operators were first invented by Goodstein in 1947. [1]

\(a\) \(a\)-ated to \(a\) eventually dominates all primitive recursive functions.

Basics Edit

When we say "\(a \times b\)," we mean "a added to itself b times":

\[a \times b = \underbrace{a + a + \cdots + a + a}_b\]

For example, \(4 × 3 = 4 + 4 + 4\).

When we say "\(a^b\)," we mean "a multiplied by itself b times":

\[a^b = \underbrace{a \times a \times \cdots \times a \times a}_b\]

For example, \(4^3 = 4 × 4 × 4\). This is the limit of standard mathematical notation.

We can takes this a step further, however. We can define a new function, "\(^ab\)" (pronounced "power tower of a's with b terms high") which means "a tetrated to b":

\[^ba = \underbrace{a^{a^{a^{.^{.^.}}}}}_b\]

where there are b as, solved from the top down (which creates bigger numbers). This is called tetration. Since the function does not have much use in most areas in mathematics, there is no standard way of notating this.

The next natural step is pentation, which is repeated tetration; hexation, which is repeated pentation; heptation, which is repeated hexation; and so forth. The terms sexation, septation, etc. are also used, but they are considered nonstandard, being Latin prefixes and not Greek.

Notations Edit

A common notation for tetration is \(^ba\) (to-the-a b). The notation was introduced by Goodstein and popularized by Rudy Rucker; its use is mainly restricted to situations where only tetration and none of the greater hyper operators are used.

The most popular notation for the general hyper-operators is Donald Knuth's up-arrow notation, where \(n\)-ation is represented by \(n-2\) arrows.

\[a + b,\, a \cdot b,\, a \uparrow b,\, a \uparrow\uparrow b,\, a \uparrow\uparrow\uparrow b,\, \ldots\]

It forms the basis for chained arrow notation, and later BEAF and its relatives. It is perhaps most well-known due to its appearance in the definition of Graham's number. In ASCII settings, the caret symbol ^ frequently replaces the arrows.

Goodstein himself used \(G(a,b,c)\) for \(b \uparrow^a c\).

Mark Cutler suggested the following extension to Rucker's notation:

\[a + b,\, a \cdot b,\, a^b,\, {}^ab,\, \overline{a}^b,\, {}^b\overline{a},\, \overline{\overline{a}}^b,\, {}^b\overline{\overline{a}},\, \ldots\]

Sbiis Saibian refined of Cutler's bar notation using counterclockwise rotation:

\[a + b,\, a \cdot b,\, a^b,\, {}^ab,\, {}_{a\leftarrow}b,\, b_{\rightarrow a},\, {}_{a\Leftarrow}b,\, b_{\Rightarrow a},\, \ldots\]

Robert Munafo uses superscript circled numbers:

\[a^① b,\, a^② b,\, a^③b,\, a^④b,\, \ldots\]

and Jonathan Bowers uses angle brackets:

\[a + b,\, a \cdot b,\, a\ \langle 1\rangle\ b,\, a\ \langle 2\rangle\ b,\, a\ \langle 3\rangle\ b,\, \ldots\]

This notation has special importance because its extensions (e.g. \(a\ \langle\langle 1\rangle\rangle\ b\)) eventually form BEAF.

Another notation duplicates the + symbol:

\[a + b,\, a ++ b,\, a +++ b,\, \ldots\]

The Big Psi Project uses duplicated asterisks, which are a common multiplication symbol:

\[a + b,\, a*b,\, a**b,\, a***b,\, \ldots\]

The double asterisk symbol \(**\) is sometimes used for exponentiation. It is common in computer languages because ^ usually means the bitwise XOR operation.

Confusingly, Sunir Shah offered a virtually identical notation that starts the stars at pentation instead:

\[a + b,\, a \cdot b,\, a^b,\, {}^ba,\, a*b,\, a**b,\, a***b,\, \ldots\]

Pseudocode Edit

// Upper hyper operators
function hyper(a, b, n):
    if n = 1:
        return a + b
    result := a
    repeat b - 1 times:
        result := hyper(a, result, n - 1)
    return result

// Lower hyper operators
function hyper_lower(a, b, n):
    if n = 1:
        return a + b
    result := a
    repeat b - 1 times:
        result := hyper_lower(result, a, n - 1)
    return result

Sources Edit

Community content is available under CC-BY-SA unless otherwise noted.