Copyright 2016-2020 by Louis Epstein,All Rights Reserved

The Simple Hyper-Operating Transformer function,or

I will mainly represent hyper-operating up-arrows with carets (^) in this article since not all browsers render the ↑ symbol and I will be using some arrows with special powers that need to be noted.

Each succeeding exponent is the solution of the entire expression below it and is preceded by a like number of up-arrows.(A tower is built without regard to the special powers brought into play when it is resolved).

Where with ultrex

2 *u* 2 = 2^2^(2^2) = 2^2^4 = 2^16 = 65536

3 *u* 2 = 3^3^27 = 3^7625597484987

and with hyper-operating ultrex

2 *hu* 2 = 2^^2^^^^4 = 2^^(2^^^2^^^2^^^2)

3 *hu* 2 = 3^^^3^^^^^^^^^^^^^^^^^^^^^^^^^^^27

with simple-hyper-operating transformation,

2 *s* 2 = 2^^2^^^^4 = 2^^(2^^^2^^^2^^^2)

3 *s* 2 = 3^^^3 (3^^^3,the value of a power tower of 7625597484987
3's,arrows) (the value of the power tower of 7625597484987 3's)

Whether one ultrexes or hyper-operating ultrexes 4 to a bound of
2 the second (final) exponent is 256,though as a straight-up power
of 4 in 4 u 2 and preceded by 256 arrows in 4 hu 2...but in
4 *s* 2 the 256 is replaced by 4^^^^4 preceded by 4^^^^4 arrows.

Further,ordinary exponentiation is done in ultrex;

the _{h}↑ or _{h}↑ are used
in hyper-operating ultrex;

but when a number is SHOT only the _{s}↑ or higher
will suffice.

Certain framework elements of ultrex carry over...
Repetitions of *s*:

X (**n** *s*'s) Y = X (**n**-1 *s*'s) (X
*s* Y).

Thus

2 *ss* 2 = 2 *s* (2 s 2).

Simple multiplication can be done with a subscript:

**n** _{99}*s* **b** means 99 *s*'s.

**n** __s__**b** means that there are
**n***s***b** *s*'s between **n** and **b**.

A second underlined *s* means
(**n** *s* **b**)
(**n** *s* **b** _{s}↑ 's)
(**n** *s* **b**)
*s*'s between **n** and **b**.

A third underlined *s* means
(**n** *s* **b**)
(**n** *s* **b** _{s}↑ 's)
(**n** *s* **b**)
((**n** *s* **b**)
(**n** *s* **b** _{s}↑ 's)
(**n** *s* **b**)
_{s}↑ 's))
((**n** *s* **b**)
(**n** *s* **b** _{s}↑ 's)
(**n** *s* **b**))
*s*'s between **n** and **b**...and so on in SHOT
fashion.

**n** (*s*) **b**

means there are
**n**
(**n**
*s* **b** *s*'s) **b** *s*'s between **n**
and **b**.

A second,third etc. set of parentheses likewise hyper-operate the number of
*s*'s in the specification of the number thereof.

**n** [*s*] **b**

means there are
**n**
(**n**
*s*
(**n**
*s* ...
(**n**
*s*
**b** layers of nesting)
**b** )
*s*'s) **b** *s*'s between **n**
and **b**.

A second,third etc. set of square brackets likewise hyper-operate the number of
layers of nesting in the specification of the number of *s*'s.

Substituting braces {} for the square brackets

**n** {*s*} **b**

represents **n** [*s*] **b**

layers of square brackets.

A second,third etc. set of braces hyper-operate the number of
layers of square brackets in the specification of the number of *s*'s.

Underlining the right parenthesis

**n** (*s*__)__ **b**

represents
**n** {*s*} **b**
repetitions of an operation being invoked to specify its
base value as the number of enclosures of the *s* to
equate to one enclosure of the *s* in the next operation.

Further underlining of either or both parentheses/braces/brackets
and/or the enclosed *s* are reserved for future
generations of expansion,which may also see the
function used to specify the number of generations.

4*s*' means
4*s* (4 *s* (4 *s*(4 *s* 4))).

4* s*' means
4

4(*s*)' means 4 (4 *s* 4) *s*'s) 4 *s*'s of layers.
We of course do not content ourselves with normal exponentiation arrows.

When engaged in hyper-operating transformation,we instead introduce
the simple-hyperoperating arrow _{s}↑ to represent it.
We will avoid *infinite* recursion,while achieving the
largest possible finite numbers by postponing halting to the last possible
moment while absolutely guaranteeing that it eventually does happen.

So with this function...every ^ now representing a
_{s}↑ ...

2 *s* 2 = 2^^2^^^^4 = 2^^(2^^^(2^^^(2^^^2))) =

2^^(2^^^(2^^^(2^^(2^^2)))) = 2^^(2^^^(2^^^(2^^(2^(2^2))))) =

...now we have to face the infinite recursion issue.

*When alone at the end,simple hyper-operating arrows merely precede the final
exponent with a number of ordinary arrows equal to itself.*

2^^(2^^^(2^^^(2^^(2^(2^^2))))) = 2^^(2^^^(2^^^(2^^16))) =

At this point the arrows before the 16 are *not* alone,
they split up...the one on the right acts like an ordinary double
arrow and creates a power tower of sixteen twos separated by ordinary
arrows("spawn of the last arrow" are always ordinary arrows) while
the one on the left waits behind.

Once the power tower is resolved,the new last arrow spawns ordinary
arrows...by performing a simple hyper-operating transformation:

2^^(2^^^(2^^^(2 s (2^^16))) =

2 is SHOT to 2^^16 with each exponent preceded by a like number of
ordinary arrows...the first of the 2^^16 exponents is 2,preceded by
2 arrows,then the second is 4,preceded by four arrows,then the third is
2^^2^^^^4,preceded by 2^^2^^^^4 arrows,then the fourth is the entire
value of the tower so far,preceded by that many arrows,
and so on through the 2^^16th exponent...ordinary arrows,right?...nothing
to be scared of!

So,do the calculations on that to get the resulting number.

2^^(2^^^(2^^^(the resulting number)) =

Here we still have three arrows,and they're still simple-hyperoperating
arrows.

2^^(2^^^(2^^(2^^(2^^...(that resulting number total 2's)...^^(2^^2))...))

Only the final ^^ drop to ordinary status just yet,and after they resolve the preceding pairs resolve in just the same fashion as before,expansion after expansion.

Then we resolve the preceding set of three arrows,with a much greater number of arrow-enhanced expansions.

Finally the first double arrows after the base are resolved.

That is the value of 2 *s* 2 and if we were to
simple-hyper-operating-transform 2 to the bound of the number we just reached,
rather than stop with a bound of 2,we would have 2 _{2}*s* 2 or
2*s*'.

But of course it is preferable to make this function *much* more powerful.

Recall that underlining __s__ means that the number of *s* operations
is equal to n *s* b,repeated operations always nested on the bound.
And * underlined* s's do not settle for the wimpy little

Enter the _{s}↑ operator,the *recursive*
simple-hyperoperating up-arrow!

On going through the first cycle of 2 * s* 2,instead of

2^^(2^^^(2^^^(2 s (2^^16)))

(2 simple-hyper-operating-transformed once to 2^^16)

we have

2^^(2^^^(2^^^(2 __s__ (2^^16)))

that is,2 SHOT 2 s 2^^16 times,nested on the bound,to 2^^16.
And since we are simple-hyper-operated-transforming every exponent is
the value of the building tower beneath it,preceded by its number of recursive
simple-hyper-operated-transforming arrows which only decline to
normal ones at the very top.Resolving 2 * s* 2 completely gives
us the number of times we continue to simple-hyper-operating-transform 2 to
ever-increasing bounds in order to reach 2

If we want a heavier load of SHOT we can employ parenthesized or bracketed
recursive simple-hyper-operating arrows with the corresponding specifications
(2 (*s*) 2 with _{(s)}↑ and 2 [*s*] 2 with
_{[s]}↑ ).
And now it is high time we stopped dealing with tiny little bases like 2 or
tiny little bounds like 2.

While we've built some pretty tall towers from such small foundations,it's
more effective by far to use numbers from
http://www.lekno.ws/A/alnumb.html as bases and the ' notation can use
them as bounds as well...replace 2 with E(2) (Epstein's Second Number) and
you can say E(2)* s'* without taking up much space and denoting
a vastly greater number.

Array-making is not something I have done much of,but imagine if you would a linear array specified by a comma thusly:

E(2)* s*',

It would not be practical to lay out the numerous comma-separated entries,
but they are the base E(2)* s*' and every exponent it would take
to simple-hyper-operating transform itself to a bound of itself,with each one
repeated in ascending order as many times as itself(the number it would have of
arrows in hyper-operated ultrexing or SHOT).
As with my prior example for the hyper-operating ultrex,imagine the base
as performing on stage at a talent show,demonstrating its skill at
self-hyperinflation.By the stage,the second entry is the

For its first act,the base (which is itself E(2) simple-hyper-operating-transformed itself-simple-hyper-operating-transformed times to itself to itself) simple-hyper-operating-transforms itself itself-simple-hyperoperating-transformed-to-itself times to a bound of itself.

The ticker goes down by one,and the base repeats its performance based on its new size.

This repeats until the ticker would reach zero,at which point the timekeeper resets the ticker to the size the base has now reached,and itself goes down by one.

This repeats until the timekeeper would reach zero,at which point the first arbiter brings in a new timekeeper of the size the base has now reached, which resets the ticker to the size the base has now reached,while the first arbiter goes down by one.

As each arbiter reaches zero it is replaced by the next arbiter further from the base,which decreases by one,with a new one the current size of the ever-growing base,as are all other entries between that arbiter and the base.

When the final arbiter reaches zero,it ceases to exist as all entries between it and the base are repopulated with ones equal to the then current size of the base.The arbiter before the last becomes the new final arbiter.

As the arbiters dwindle,the replacement cycles continue,until finally the last arbiter is gone,then the timekeeper,then the ticker.

Calculation halts.

At this point,the critics in the audience who were hoping to catcall
"doesn't halt" and throw croutons at the stage file out of the
auditorium,muttering "naive extension" and squabbling about how many
scroobols of loggion marks are in a ducquaxul,composing letters in their
heads about how **of course** their 2↑↑↑3-dimension
arrays,which are TETRATIONAL,have to be bigger than ones with only
Skewes' Number^{G(centillion)}-dimensions that are merely
exponential.

The poor expanded base is left on stage wanting to keep going,to conjure up a whole new array of ticker,timekeeper,and arbiters based on its current size.

*How can we not have pity on the poor little thing?*

A simple additional apostrophe

E(2)* s*','

denotes the ability to thus regenerate the whole line with updated entries a number of times equal to the starting value.

A subscripted preface to the apostrophe
E(2)* s*',

provides a bound to which that starting value is simple-hyper-operating-transformed itself times to set the number of times regenerations are permitted.

MORE MAY COME LATER on replenishment,reincarnation,and resurrection.

In the meantime,enjoy this creation and the **Blindingly Big Number** it
has enabled.

First edition April 25,2020.

The next day I created a function a LHOT bigger.

This function was accordingly renamed ("Super" to "Simple") April 27th.

{} and (