Hyper operator

Hyper operators are extensions to the standard binary operators addition, multiplication, and exponentiation. Multiplication is repeated addition, and exponentiation is repeated multiplication, so it is natural to extend them further &mdash; repeated exponentiation is called "tetration," for instance. When used on the s, 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.

Basics
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 &times; 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 &times; 4 &times; 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 a s, 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
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 notation was introduced by

The most popular notation for the general hyper-operators is 's up-arrow notation.

\[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
// 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