Hyper-E notation

Hyper-E Notation (E# for short) is a notation for large numbers devised by Sbiis Saibian.4.3.1 - A 2nd Grader's Close Encounter with the Infinite - Large Numbers 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) = En##n eventually dominates all primitive recursive functions.https://sites.google.com/site/largenumbers/home/appendix/c In fact, in the fast-growing hierarchy, \(n \mapsto\textrm 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.https://web.archive.org/web/20160513034718/http://snappizz.com/termination
== Original definition ==
The original Hyper-E Notation consists of a sequence of one or more positive integer arguments separated by hyperions (or hyper marks) #. We notate this as E[b]##...#. b is called the base — if it is omitted, as it often is, it defaults to 10. "E[b]d" is also equal to "b^d".
The three rules are as follows:
*Rule 1. If there are no hyperions:
*: \(\textrm E[b]x = b^x\).
*Rule 2. If the last entry is 1:
*: \(\textrm 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(iteration last):
*: \(\textrm E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_{n-2}}\#{a_{n-1}}\#{a_n} =\)
*: \(= \textrm E[b]{a_1}\#{a_2}\#{a_3}\cdots\#{a_{n-2}}\#(\textrm 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 .
#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.
The priority of the rules are stated in the original webpage below the definition, "There are 3 rules used. If your given a E# expression, you first check to see if rule 1 applies. If it does not you check for rule 2. If that doesn't apply you go to 3." It disables \( a_n \) being 1 in the 3rd rule and avoids an overlapping case classification.
== Extended definition ==
Extended Hyper-E Notation allows multiple hyperions to appear between each entry. The number of hyperions following entry is represented by h(n). For the sake of this definition, is a shorthand for n successive hyperion marks. For example, a full expression would be written E(b).... Saibian uses @ to indicate the rest of the 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 .
#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.)
#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.)
== Examples ==
* E6 = E6#1 = = million
* E100 = E100#1 = = 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) = E = = googolplex
* E100#3 = E(E100#2) = E1010100 = = 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 = 10303
* E303#2 = ecetonplex = EE303 = 1010303
* E303#3 = EEE303 = 101010303 = ecetonduplex
* E1#3 = EEE1 = 101010 = trialogue
* E1#4 = EEEE1 = 10101010 = tetralogue
* E1#10 = EEEEEEEEEE1 = 10^^10 = Decker
* E303#6 = EEEEEE303 = 101010101010303 = 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 = , hence the name.
* 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.
* E100##100#100 = graatagold
*: This expression decomposes into Ea##b expressions by applying rule 4 repeatedly.
* 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.
* 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#100100
*: 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#(100100).
== Relationship to Other Notations ==
The first segments of Hyper-E notation are based on exponentiation, i.e. En equals 10n. Nesting in a single-entry Hyper-E produces iterated exponentiation, such as EEEn=101010n. Then, hyperion marks come into play. Because hyperion marks are crucial to the recursion in this notation, certain arrangements of hyperions can indicate similarity to other notations defined by recursion.
Hyper-E can relate to arrow notation through the following rule: Fish, Comparison of up-arrow notation with hyper-E notation 1 July 2021
: \(a \uparrow^{c}b = E(a)\underbrace{1\#1\#...1\#}_{(1\#) \times (c-1)}b\)
for positive integers a, b, c. For example,
* a↑b = E(a)b
* a↑↑b = E(a)1#b
* a↑↑↑b = E(a)1#1#b
* a↑↑↑↑b = E(a)1#1#1#b
== Pseudocode ==
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.
 function Eb(, , ..., , ): //Default value of b is 10
 
 if n = 1:
 return 
 
 if = 1:
 return Eb(, , ..., )
 
 z := Eb(, , ..., , - 1)
 
 return Eb(, , ..., , z)
 
 function xEb(, , ..., , ;
 , , ..., , ): //Default value of b is 10
 
 if n = 1:
 return 
 
 if = 1:
 return xEb(, , ..., ;
 , , ..., )
 
 if > 1:
 r := 
 z := 
 zseq := z, z, ..., z, z (r times)
 h := 
 hseq := h, h, ..., h, h (r - 1 times)
 return xEb(, , ..., , zseq;
 , , ..., , hseq)
 
 z := xEb(, , ..., - 1;
 , , ..., , )
 return xEb(, , ..., , z;
 , , ..., )
== Sources ==
== See also ==
*:Category:Hyper-E numbers
*Exponentiation
*Cascading-E notation
Browse the Hyper-E numbers
ja:ハイパーE表記 fr:Notation hyper-E de:Hyper-E Notation nl:Hyper-E notation zh:超E符號 ru:Гипер E нотация
Category:Notations
Category:Functions
Category:Functions by Sbiis Saibian