Lecture
Hyper-E notation (abbreviated E#) is a notation for large numbers developed by Sbiis Saibian. It was first introduced in his web book “One to Infinity: A Finite Journey” on November 19, 2011, and was later generalized into Extended Hyper-E Notation (abbreviated xE#). Hyper-E notation is an improved version of a notation Sbiis Saibian developed in his childhood.Not to be confused with the ε-function or the E-function of the nihilist absolutists.
The function E# is not primitive recursive, and in particular, the function E(n) = En##n eventually dominates all primitive recursive functions. In fact, within the fast-growing hierarchy it dominates for all values and is itself dominated in turn.
E# and xE# are part of a larger notation system, the Extensible-E System, which also includes Cascading-E Notation.
Nathan Ho and Wojowu proved the termination of the Hyper-E notation rules.
The original hyper-E notation consists of a sequence a n of one or more positive integer arguments, separated by hyperions (or hyper marks) #. We denote this as E[ b ] a 1 # a 2 #...# a n . b is called the base — if it is omitted, as is often the case, it defaults to 10. "E[ b ] d " is also equal to " b ^ d ".
The three rules are as follows:
.
.
In simpler terms:
The priority of the rules is stated on the original web page below the definition: “3 rules are used. If you are given an E# expression, first check whether rule 1 applies. If not, check rule 2. If that doesn't apply either, move on to rule 3”. This corresponds to the 1st clause of rule 3 and avoids duplicating the case classification.
Extended hyper-E notation allows placing multiple hyperions between each entry. The number of hyperions following entry n is denoted h ( n ) . For simplicity of this definition, #n— is shorthand for n consecutive hyperion marks. For example, the full expression would be written as E( b ) a 1 # h (1)a 2 # h (2)...# h ( n - 1)an # h ( n )Saibian uses the symbol @ to denote the rest of the expression, whereas Bowers uses the symbol # to denote the rest of the array.
The difference between the original and extended notation is that the extended hyper-E notation allows more than one sequence of digits.
.
.
.
(note=).
This is similar to the rules for writing linear arrays. We can also rewrite this in plain language:
This is an example of rule 1 with an expression consisting of a single entry. Since the base defaults to 10, we can shorten E(10)100 to E100.
This is an example of rule 3 (rule 4 upon expansion) with a two-entry expression. In the second expression the parentheses can be omitted: E(E100#1) = EE100#1.
Repeated application of rule 3: E1#100 = EE1#99 = EEE1#98 = ...
This is the same as E1#100, but with a different first entry.
E100#101 = EE100#100 = 10 grangols Hence the name.
Now let's move on to three-entry expressions.
Increasing the value of the third entry leads to deeper and deeper nesting.
Four-entry expressions are similar — they create ever deeper nesting at the array level below. This can also be written as E100##4; the beginning of the next level of notation.
Now we've arrived at extended hyperion notation. Two consecutive hyperions ( deuterohyperions ) indicate repetition at the lower level.
This expression decomposes into expressions of the form E a ## b by repeated application of rule 4.
We ignore the first ## symbol until the second one is expanded and all the hundreds are resolved.
Three hyperion marks ( trito-hyperions ) represent a repetition of two hyperion marks. Remember that double marks are resolved from right to left.
Quadruple hyperions decompose into triple ones.
Sets of 100 hyperion marks decompose into 99, 99 — into 98, and so on. Also note that the superscript 100 means there are 100 marks and should not be confused with E100#( 100 100 ).
The first segments of Hyper-E notation are based on exponentiation, i.e. En equals 10 n . Nesting in the single-entry Hyper-E notation leads to iterated exponentiation, e.g. EEEn=10 10 10 n . Then the hyperion marks come into play. Since hyperion marks are crucial to the recursion in this notation, certain combinations of hyperions can indicate similarities to other notations defined by recursion.
Hyper-E can be related to up-arrow notation by the following rule:
for positive integers a, b, c. For example,
Sbiis Saibian showed that it is the first function in the fast-growing hierarchy that eventually dominates all functions in the E# hierarchy.
For a fixed number of variables, the original Hyper-E notation is primitive recursive, although the values it produces vastly exceed the capabilities of any computer. The extended Hyper-E notation is not primitive recursive for two or more variables.
function Eb( a1,a2 , ..., an-1,an ): //The default value of b is 10
if n = 1:
return b a1
if an = 1:
return Eb(a1,a2 , ..., an-1 )
z := E b (a1,a2,..., an-1,an-1)
return Eb (a1,a2,..., an-2, z )
function xEb(a1 ,a2, ..., an-1, an ;
h1, h2, ..., hn-2,hn-1): //The default value of b is 10
if n = 1:
return b a 1
if an = 1:
return xEb ( a1 , a2 , ..., an-1 ;
h1 , h2 , ..., hn-2 )
if hn-1 > 1:
r := a n
z := a n-1
zseq := z , z , ..., z , z (r times)
h := a h - 1
hseq := h , h , ..., h , h (r-1 times)
return xE b ( a1 , a2 , ..., an-2 , zseq ;
h1 , h2 , ..., hn-2 , hseq )
z := xE b ( a1 , a2 , ..., an-1;
h1 , h2 , ..., hn-2 , hn-1 )
return xEb ( a1 , a2 , ..., an-2 , z ;
h1 , h2 , ..., hn-2 )
Comments