# Sbiis Hyper-E notation
“Seven Doubles BGD KPRT (709) of Foundation:
He engraved them, He carved them,
He permuted them, He weighed them,
He transformed them.
And with them He formed
Seven planets in the Universe,
Seven days in the Year,
Seven gates in the Soul,
male and female.”
– Sefer Yetzirah 4:6
Review by Giga Gerard, North-Holland, February 2013.
# Scientific E in perspective
There are various numbering systems possible,
the number “three hundred sixty five”
for examples, can be counted:
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111,
a common year, in days of the months:
31+28+31+30+31+30+31+31+30+31+30+31,
with Roman numerals CCCLXV = 100+100+100+50+10+5,
in the decimal system we have
365 = 300+60+5 = 5*1+6*10+3*10*10
binary computers read in 101101101
or 16d in hexadecimal code,
scientific notation approximates
3.65E2 ~ 4E2 ~ 1E2
= E2 (enter Hyper-E).
Humanity started (e.g. in ancient Egypt)
from a number of repeated units 1.. :n
until such representations became unworkable
and decimal notation was invented.
There, appending a 0
to the right will repeat the number on the left
*10 tenfold.
On top of that, scientific notation,
right of the E sign,
counts the number of decimals
or decimal zeros, which are repetitions by *10
amounting to a power 10^p
or 10**p.
# Compare Hyper-E
From 0 to E
and farther, there are many types of repetition operations possible,
the question is:
when you'd like to start counting or repeating operators themselves.
Sbiis postpones this moment until after
he has introduced another # repetition sign,
(formerly I used a hash #
for word repetition, now my colon
: is more to the point).
Note that Sbiis didn't opt for
nEE3 to reduce to
1E1E1En
but writes En#3 instead.
Here E functions both
as a single operator and (with # on the right)
as a left bracket.
Any function Fn
of one variable could be repeated the very same way:
as a base
of a function tower,
in a # linear, ## plane,
#.. multidimensional array,
as below.
En#3 = EEn#2 = EEEn#1 = EEEn = EE10^n
== 10^10^10^n = 10^^3+^n ~ n^^4
En#r = EEn#r- == E..n :r (power towers)
== 10^..n :r = 10^^r+^n ~ n^^r1
(a prefixed plus +^n postpones the right operation
until the left is decremented, where it is put on top)
Ea#n#2 = Ea#Ea#n#1 = Ea#Ea#n ~ Ea#a^^n1
~ a^^a^^n1 ≈ n1^^^3
Ea#n#r = Ea#Ea#n#r- == Ea#..n :r ~ Ea#..a^^n1 :r-
~ a^^..n1 :r ~ a^^^r+^^n1 ≈ n1^^^r1
Ea#a#n#r = Ea#a#Ea#a#n#r- == Ea#a#..Ea#a#n :r-
~ a1^^^..n1 :r ≈ n1^^^^r1
E.a#..n#r :s ≈ n1^..r1 ^:s2 (superpowers by primitive recursion)
Er##c (c=s2) ~ r1→r1→c = r1→2→c1
Ea##n#2 = Ea##Ea##n ~ a→2→(a1→2→n1) ~ an→2→3→2
Ea##n#3 = Ea##Ea##Ea##n ~ an→2→4→2
Ea##n#r = Ea##..n :r ~ an→2→r1→2
Ea##a#n#2 ~ an→2→3→3
Ea##a#n#r ~ an→2→r1→3
Ea##n##r ~ a→2→n1→r
Ea##a##n#2 ~ an→2→2→3→2
Ea##a##n##r ~ a→2→2→n1→r
E.a##..n##r :s ~ a→.2→..n1→r :s (row of chained arrows)
Er###c1 (c=s1) ~ 3→↑r1→c ~ {3,3,r,c}
Ea###n#2 ~ 3→↑2→(3→↑a→n) ~ an→↑2→3→2
Ea###n##r ~ a→↑2→n1→r
Ea###.a##..n :r ~ a→↑.2→..a1→n :r
Ea###n###r1 ~ a→↑2→↑n1→r
E.a###..r1 :c ~ 3→↑..a1→r :c
Er1####c1 ~ 3→↑↑r→c ~ {3,3,3,r,c}
Er1#..c1 #:t2 ~ 3→↑..r→c ↑:t ~ r→↑..c ↑:t1
~ r→→c→t1 ~ {.3,..,r,c} :t1 (row of Beaf)
{a,b,[1]2} < Ea#[1]b (a=c1 b=t2) < {a,b1,[1]2}
replaces Sbiis' ^ by #[1] and Bowers' (1) by ,[1]
Thus in expressions WEYm#n
{E∉Y}
the substring to repeat begins left of the E
bracket,
or else select from the right of the rightmost
E
(we prefer W,X,Y,Z wildcards, Sbiis @).
# Hyper-repetition
You can apply hyper-repetition by #
to any multivariable function or array structure
G,
so GXp#Z
{G#∉X}
will be nested naturally
in its right free parameter p (the biggest)
and subarrays X are waiting
for their hyper-repetitions to drop #1
at the end.
This Hyper system is also useful for operators,
with an identity operation O stop
or a left bracket (the closing bracket is waved at the right end,
grave ` perhaps.
Sbiis' hyper-E is itself a hypered operator, proof of
En#Z = 10^n#Z
is trivial.
An example is worked out, that E3##4#64
best estimates Graham's number.
a^t#b1 = a^(a^t#b
== a^(..t#1 :b1
= a^..t :b1 = a^^b1+^t
a^^^b = a^^^b+^^1
= a^^..1 :b = a^^1#b
a^1#1#b1 = a^1#(a^1#1#b == a^1#(..a :b
= a^1#(..a^^a :b-
== a^^..a :b1 = a^^^b1
a^..b ^:cd = a^...1#..b ^:c :d (c≥1 d≥0)
= a^.1#..b :d (c=1)
= a^1##d+#b <~ a^b##d1 ≈ 2^b##d1
3→3→4 = 3^^^^3
= 3^^^1#3 = 3^1#1#1#3 = 3^1##3+#3
~ 2^3##4
3→3→4#2 = 3→3→(3→3→4) ~ 2^3##4#2
3→3→4#64 = 3→3→(..4.) :64: ~ 2^3##4#64
<~ E3##4#64 ~ 3→2→65→2
In the last expression the hypered operator ^
serves Hyper-E an approximation of
Gardner's
Graham's number.
Graham's was the largest integer used in a serious article.
# Hyper-function speed
Translate Sbiis Hyper-E operation to function format
to see how this algorithm works.
Instead of plain EX
write E(X)
and instead of Sbiis # hashes
write , comma separators.
Let RegExp ,{n}
count commas and use dot-selection
.S.. :n
to repeat Substrings,
optionally repeating both Left and Right substrings
L..X.R
:n:
within the expression.
E(n,3) = E(E(n,2)) = E(E(E(n,1))) = E(E(E(n))) = 1E1E1En
E(y,1) = E(y) = 1Ey
E(y,z1) = E(E(y,z)) == E(..y,1.) :z1:
= E(..y.) :z1: = 1E..1Ey :z
E(X,1) = E(X)
E(X,y,z1) = E(X,E(X,y,z)) == E(X,..y,1.) :z1:
= E(X,..y.) :z1:
E(W,{s}1) = E(W) (count off)
E(X,{s}y,z1) = E(X,{s}E(X,{s}y,z))
== E(X,{s}..y.) :z1: (motor rule)
E(W,{r}y,{s1}z1) = E(W,{r}y,{s}y,{s1}z)
== E(W,{r}.y,{s}..y)) :z (size ruler)
Initially it looks like Hyper-E is much slower than chained arrows,
because Hyper-E does not count down the outer parameter,
but drops it flat.
So how does it eventually (over multiple dimensions)
catch up and run on a par?
When we compare the progress of the two systems
in my first calculations,
the size of a Hyper-E row (the 1st) equals an entry (the 4th)
of chained arrows,
a 2nd dimension ### of Hyper-E equals
chained arrows 1st dimension (a row),
an extra cube ####b
almost equals an extra plane of
→↑↑2→b and so on…
So on multiple dimensions
Hyper-E always lags only one dimension behind.
Professionals would say
E3#{ω}2
= 3→↑{ω}2
and nod (but we are amateurs).
We can prefix other functions than E
(or operators or array algorithms) to be
hyper-repeated by # hashes.
Functions not faster than linear Beaf arrays
will receive a significant boost.
Higher arrays can be properly analysed,
when you put the hyper-operators on top.
Sbiis' hashes are a fine benchmark,
on a dim-par (having multidimensional parity) with my
→↑{n}
superarrows,
but easier, because the #
evaluation train always departs from the outer right.
# Stand-alone Hyperions
Without a functional prefix,
Sbiis' hyperion a#b1
= a#b = a
is a lame creature.
I suggest two solutions to make that creature walk.
First the primitive, to addition.
Following, my original hash was a multiplyer (of words),
and I like that best!
a#b1 = `a#b
== `{b}a#1 = `{b1}a (now let every bracket ` change to 1)
= b1a = b+1+a
a#{1}b1 = a#{0}a#{1}b (if there is no sign left of a, just repeat
= aa#{1}b == a..#{1}1 :b1 ..decremented #{n}
= a..a :b = a*b1 = (b+1)×a ..as usual)
a#b1 = a+0#b1
= a+`a+0#b == a+`..0#1 :b1
= a+..a :b = (b+1)×a
For both elementary solutions a row of single Hyperions can be shown
to stay within the superexponential (Grzegorczyk hierarchy) similarly.
From addition to primitive recursion we'd create a
basic function
row,
but my favorite algorithm is the linear Hyperion as worked out below.
a#b = a*b
a#b#c = a#`..b :c = a**c+*b ≈ b**c1
a#b#c#d = a#b#`..c :d ≈ b***d+**c1 ≈ c1***d1 (spoils row of a)
a#b#c#d#e = a#b#c#`..c :e ≈ c1****e+***d1 ≈ d1****e1
a##k1 = a..a :k ~ a1*{k}a1 = a1*{k1}2 = a1→2→k1
As expected my repeating Hyperions are 1 entry slower
on the row than
Hyper-E.
Past the row this difference loses significance,
so all further grafts run at the same pace.
Next read my review of Cascading-E notation.