Template:Function
**Hyper-E Notation** (**E#** for short) is a notation for large numbers devised by Sbiis Saibian.^{[1]} It was first introduced on his Web book *One to Infinity: A Finite Journey* on November 19, 2011, and was generalized to **Extended Hyper-E Notation** (**xE#** for short). Hyper-E Notation is a refined version of a notation Sbiis Saibian devised as a child.

E# is not primitive recursive, and specifically the function E(*n*) = E*n*##*n* eventually dominates all primitive recursive functions.^{[2]} In fact, in the fast-growing hierarchy, \(n \mapsto E100\#\#n\) dominates \(f_n\) for all \(n < \omega\) and is itself dominated by \(f_\omega\).

E# and xE# form part of a larger notation, the Extensible-E System, that also encompasses Cascading-E Notation.

Nathan Ho and Wojowu proved termination for the rules of Hyper-E Notation.^{[3]}

## Original definition Edit

The original Hyper-E Notation consists of a sequence Template:Asq of one or more positive integer **arguments** separated by **hyperions** (or hyper marks) #. We notate this as E[*b*]Template:Asq#Template:Asq#...#Template:Asq. *b* is called the **base** — if it is omitted, as it often is, it defaults to 10. "E[*b*]*d*" can also be denoted as "*b*^*d*".

The three rules are as follows:

**Rule 1.**If there are no hyperions:- \(E[b]x = b^x\).

**Rule 2.**If the last entry is 1:- \(E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_n}\#1 = E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_n}\).

**Rule 3.**Otherwise:- \(E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_{n-2}}\#{a_{n-1}}\#{a_n} =\)
- \(= E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_{n-2}}\#(E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_{n-2}}\#{a_{n-1}}\#{a_n-1})\)

In plain English:

- If there is only one argument
*x*, the value of the expression is*b*^{x}. - If the last entry is 1, it may be removed.
- Otherwise...
- Evaluate the original expression, but with the last entry decreased by 1. Call this value
*z*. - Remove the last two entries of the expression.
- Add
*z*as an entry to the end of the expression.

- Evaluate the original expression, but with the last entry decreased by 1. Call this value

## Extended definition Edit

Template:Function
**Extended Hyper-E Notation** allows multiple hyperions to appear between each entry. The number of hyperions following entry Template:Asq is represented by *h*(*n*). For the sake of this definition, #^{n} is a shorthand for *n* successive hyperion marks. For example, a full expression would be written E(*b*)Template:AsqTemplate:HmTemplate:AsqTemplate:Hm...Template:HmTemplate:AsqTemplate:Hm. Saibian uses @ to indicate rest of expression such as Bowers uses # to indicate the rest of the array.

The difference between original and extended notation is that extended Hyper-E notation allows more than one consecutive #'s.

**Rule 1.**If there are no hyperions:- \(E(b)x = b^x\).

**Rule 2.**If the last entry is 1:- \(E(b) @ \#^{h(n-1)}{a_n}\#^{h(n)}1 = E(b) @ \#^{h(n-1)}{a_n}\).

**Rule 3.**If \(h(n-1)>1\):- \(E(b) @ \#^{h(n-2)}{a_{n-1}}\#^{h(n-1)}{a_n} = E(b) @ \#^{h(n-2)}{a_{n-1}}\#^{h(n-1)-1}{a_{n-1}}\#^{h(n-1)}{a_n-1}\).

**Rule 4.**Otherwise:- \(E(b) @ \#^{h(n-2)}{a_{n-1}}\#{a_n} = E(b) @ \#^{h(n-2)}(E(b) @ \#^{h(n-2)}{a_{n-1}}\#{a_n-1})\) (note \(\#^1\) = \(\#\)).

It seems similar to linear array notation rules. We can also rewrite it in plain English:

- If there is only one argument
*x*, the value of the expression is*b*^{x}. - If the last entry is 1, it may be removed.
- Let
*h*be the length of the last set of hyperion marks. If*h*> 1:- Remove the last entry of the expression and call it
*r*. - Again remove the last entry of the expression; this time call it
*z*. - Repeat
*z**r*times with*h*- 1 hyperion marks in between each repetition. Append this to the end of the expression. (Restore a removed hyperion mark sequence to glue the two expressions together.)

- Remove the last entry of the expression and call it
- If the last set of hyperion marks is of length one:
- Evaluate the original expression, but with the last entry decreased by 1. Call this value
*z*. - Remove the last two entries of the expression.
- Add
*z*as an entry to the end of the expression. (Again, restore a removed hyperion mark sequence to glue the two expressions together.)

- Evaluate the original expression, but with the last entry decreased by 1. Call this value

## Examples Edit

- E(10)6 = E6 = E6#1 = 10
^{6}= million - E(10)100 = E100 = E100#1 = 10
^{100}= googol- This is an example of rule 1 with a one-entry expressions. Since the base defaults to 10, we can abbreviate E(10)100 as E100.

- E100#2 = E(E100#1) = E10
^{100}= 10^{10100}= googolplex - E100#3 = E(E100#2) = E10
^{10100}= 10^{1010100}= googolduplex- This is an example of rule 3 (rule 4 in the expansion) with a two-entry expressions. In the second expression, the parentheses can be omitted: E(E100#1) = EE100#1.

- E303#1 = E303 = eceton = centillion = 10
^{303} - E303#2 = ecetonplex = EE303 = 10
^{10303} - E303#3 = EEE303 = 10
^{1010303}= ecetonduplex - E1#3 = EEE1 = 10
^{10101}= trialogue - E1#4 = EEEE1 = 10
^{101010}= tetralogue - E1#10 = EEEEEEEEEE1 = 10^^10 = Decker
- E303#6 = EEEEEE303 = 10
^{1010101010303}= ecetonquintiplex - E1#100 = EEE...EEE1 (100 E's) = giggol
- Repeated application of rule 3: E1#100 = EE1#99 = EEE1#98 = ...

- E100#100 = EEE...EEE100 (100 E's) = grangol
- This is the same as E1#100, but with a different first entry.

- E100#101 = EEE...EEE100 (101 E's) = grangolplex
- E100#101 = EE100#100 = 10
^{grangol}, hence the name.

- E100#101 = EE100#100 = 10
- E100#100#2 = E100#(E100#100) = EEE...EEE100 (grangol E's) = grangoldex
- Now we enter three-entry expressions.

- E100#100#3 = E100#(E100#100#2) = E100#(E100#(E100#100)) = EEE...EEE100 (grangoldex E's) = grangoldudex
- Increasing the value of the third entry makes nesting deeper and deeper.

- E100#100#100#100 = E100#100#(E100#100#100#99) = E100#100#(E100#100#(E100#100#100#98)) = ... gigangol
- Four-entry expressions are similar — they create deeper and deeper nesting in the array level below them. This can also be written as E100##4; the beginning of the next level of the notation.

- E100##100 = E100#100#100#...#100#100#100 with 100 repetitions of 100 = gugold
- Now we have arrived at Extended Hyper-E Notation. Two successive hyperion marks (
*deutero-hyperions*) indicate repetition at the lower level.

- Now we have arrived at Extended Hyper-E Notation. Two successive hyperion marks (
- E100##100#100 = graatagold
- This expression decomposes into E
*a*##*b*expressions by applying rule 4 repeatedly.

- This expression decomposes into E
- E100##100##100 = E100##100#100#...#100#100 with 100 repetitions of 100 = gugolthra
- We ignore the first ## until the second one has been expanded and all the 100s have been solved.

- E100###100 = E100##100##...##100##100 with 100 repetitions of 100 = throogol
- Three hyperion marks (
*trito-hyperions*) constitute a repetition of two hyperion marks. Remember, the double marks are solved from right to left.

- Three hyperion marks (
- E100####100 = E100###100###...###100###100 with 100 repetitions of 100 = teroogol
- Quadruple hyperions decompose into triples.

- Godgahlah = E100#####...#####100 with 100 hyperion marks or E100#
^{100}100- Sets of 100 hyperion marks decompose into 99s, 99s decompose into 98s, etc. Also note that the superscript 100 means that there are 100 #'s, and should not be confused with E100#(
^{100}100).

- Sets of 100 hyperion marks decompose into 99s, 99s decompose into 98s, etc. Also note that the superscript 100 means that there are 100 #'s, and should not be confused with E100#(

## Relationship to Other Notations Edit

The first levels of Hyper-E notation are based on on Exponentiation. That is, E(n) equals 10^n. Later on, the more E added, the greater the power tower until you start seeing hyperion marks. Different levels of singular hyperion marks can indicate different notations. For example, Hyper-E can relate to Arrow notation through the following rule: For any number defined as E(n)#(n)#(n)#(n)...#(n) with an X amount of n's, the corresponding figure in arrow notation is N ^^^...^^^ N+1 with an X amount of up arrows.

## Pseudocode Edit

For a fixed number of variables, the original Hyper-E Notation is primitive-recursive, although the values it produces are well beyond that of any computer. The extended Hyper-E Notation is nonprimitive-recursive for two variables or more.

functionE_{b}(Template:Asq, Template:Asq, ..., Template:Asq, Template:Asq):ifn= 1:returnb^{Template:Asq}ifTemplate:Asq = 1:returnE_{b}(Template:Asq, Template:Asq, ..., Template:Asq)z:= E_{b}(Template:Asq, Template:Asq, ..., Template:Asq, Template:Asq - 1)returnE_{b}(Template:Asq, Template:Asq, ..., Template:Asq,z)functionxE_{b}(Template:Asq, Template:Asq, ..., Template:Asq, Template:Asq; Template:Asq, Template:Asq, ..., Template:Asq, Template:Asq):ifn= 1:returnb^{Template:Asq}ifTemplate:Asq = 1:returnxE_{b}(Template:Asq, Template:Asq, ..., Template:Asq; Template:Asq, Template:Asq, ..., Template:Asq)ifTemplate:Asq > 1:r:= Template:Asqz:= Template:Asqzseq:=z,z, ...,z,z(rtimes)h:= Template:Asqhseq:=h,h, ...,h,h(r- 1 times)returnxE_{b}(Template:Asq, Template:Asq, ..., Template:Asq,zseq; Template:Asq, Template:Asq, ..., Template:Asq,hseq)z:= xE_{b}(Template:Asq, Template:Asq, ..., Template:Asq - 1; Template:Asq, Template:Asq, ..., Template:Asq, Template:Asq)returnxE_{b}(Template:Asq, Template:Asq, ..., Template:Asq,z; Template:Asq, Template:Asq, ..., Template:Asq)

## Sources Edit

- ↑ 4.3.1 - A 2nd Grader's Close Encounter with the Infinite - Large Numbers
- ↑ https://sites.google.com/site/largenumbers/home/appendix/c
- ↑ http://snappizz.com/termination

## See also Edit

Browse the Hyper-E numbers |
---|

Template:Saibian's Hyper-E numbers |