Ψ. Construction Index X

• Number operations
  • Prelude
  • 1. Natural repetition
    • Addition?
    • Multiplication!!
    • box: Context of empty operations
    • Maths with make-up
    • Signs
    • Colours
    • Meta-methods
    • Indication
    • Substitution
    • box: Hyperarithmetical code
    • Repetition
    • Variation
    • The capacity of counting
    • Cosmic information resources
    • Our little universe
    • Chance functions
    • Addictive counting
    • Ancient history of Big numbers
    • In Egypt, India and Greece
    • box: Counting on the Lotus Sutra
    • Untold number records
  • 2. Towards the Ackermann numbers
    • Star spangled super-powers
    • Backslashes
    • Beyond logarithmic senses
    • Primitive recursive family
    • box: Ackermann level functions
    • Ackermann's jump from primitive recursion
    • Inverse and infinite iteration
    • Unit -
    • Unit ω
    • Deeper than counting
    • Transcendental numbers
    • Transcendent numbers
    • box: The countability criterion
    • Big number holes
    • Rules of precedence
    • Right minority and majority operators
    • box: Presiding house rules
    • Operator comparison
    • Various unbracketed
  • 3. Chained arrows versus subscripting
    • Conway's chained arrows
    • A single operator subscript
    • Passing a row of chained arrows
    • box: Conway level functions
    • A row of operator subscripts
    • box: Single parameter substitution
    • Subscript mixation
    • Mixed majority arrows?
    • Mixed minority stars
    • Addictive subscripting
    • Minority pluses
    • Mixability of pluses
    • Arrows quarters
    • Repainting up-arrows
    • Redrawing right arrows
    • Mixing down arrows
    • Recursive arrow mixation
    • Revolving the axis
    • under 2010 construction
• Function sizes
  • Summary
  • 4. Super-powers of bigO
    • Generic rules
    • Basic bigE
    • Basic bigI
    • Axioms of addition
    • Definition lists and function hierarchy
    • box: Grzegorczyk's subclasses
    • Inverse iteration
    • From bigA to fractation
    • Basic bigA and affiliates
    • Half-speed super-powers
    • Fractional super-powers
    • Super-factorial bigU
    • Extending the factorial
    • Speed of the super-factorial
    • Operation Babelfish
    • Péter's recursion
    • Prefix Pe a parameter
    • Pa gone fishing
    • The catch-all
    • Superior bigY
  • 5. First row of parameters
    • Crafting by grafting
    • General recursive baby steps
    • box: A walk on the Ackermann level
    • Multiple substitution is futile
    • Graham's Og
    • Expressing a world record
    • How Og hops back
    • How Og is jumped over
    • Recursive grafting on Og
    • Front row bigE
    • Home of subscripted arrows
    • Race against chained arrows
    • box: Order past Ackermann and Conway
    • Recursive grafting on super-chained arrows
    • Front row bigI with waitor
    • Home of subscripted stars
    • Parameter stock to row shoot
    • Front row bigA
    • Addictive pluses in row context
    • Fixing the affiliate functions
    • Testing the nesting
    • Shallowness of fixed receptors
    • Empower those iterators
    • Vana expansion
    • Operatorial design
    • box: Cursed
    • Whole row of waitors in bigY
    • Super-factorial row bigU
    • Algorithms over the first row
    • under 2010 construction
  • 6. Dimensions
    • Under Construction
    • Bowers' extended arrays
    • Front row BEAF
    • Company on the Bowery
    • Building dimension blocks
    • Diacritical remarks
    • box: Boosting BEAF
    • Exploding array functions
    • Dimensions in EAF
• Reference
  • Dictionary of Signs
  • box: Standard variables
  • Pedigree of Functions
  • Glossary of Concepts
  • Library of Links
• Participation
  • Authors

When you count you repeat a certain unit – a single entity. Stars, spirals, sleep, sheep, sets, seconds, satyrs, smiles or sand grains – all objects are subjects for counting, as long as their individual units can be recognized.
Any two objects are separated by some space and space can be measured in units. These measures can be items for a comparative list, etcetera... until one fails to find meaning and the item's separator is just empty space .

In real life, except for quantity quality always matters. It is perfectly possible to sell a quantity of pigs in exchange for a selection of roots and a busty woman of bad reputation, without knowing their exact number. To belittle a people who only have use for counting numbers up to three is no less barbaric.

The initial unit of arithmetic is one 1 and by repetition of 1.. you can count natural numbers.
The natural representation of zero   ..is nothing!

Don't think of addition as an operation on numbers. Like zero, addition doesn't actually exist. When we relate it to the first operation of multiplication, addition can be defined as a zeroth operation – the operation without stars.
We add all integers in our notation for natural counting automatically – by simply joining their units with 0* space in between. The old-style plus + operator is unmasked here as an empty star.

Peano's successor function S(n) = n+1 uniquely covers all numbers 1.. starting from n=0 by iteration of S, and thereby defines the set of natural numbers.
But it is preposterous to name individual integers with a function or a set. Who would order S(S(0)) baked eggs? Mathematicians are crazy, and they still have to count! (Count the (depth of nested) brackets…)

§1.0.2. Multiplication!!

There are two ways to define multiplication – by repeated addition or by repeated substitution. In our notation a*b the a is repeated b times, which is a binary operation on a pair (a,b) of numbers. We use the single star * as operator, to multiply left operant a (called the item) by right operant b (the iterator).

We write multiplication as a*b and not as b×a because we'd like to position higher iterators on the right.
The second evaluation above shows that multiplication can also be defined by substitution b [1:a] of value a for each unit 1 in natural number b.

In our experience multiplication is a messy business, in need of an operator. Its classic notation ab without an operator sign, obscures the arithmetical fact that we add numbers by simply joining and counting them. There doesn't seem to be any place for primordial zero 0 in a world of instant multiplication, where all is 1.

In pure mathematics new constructs may arise from multiplication that shy away from direct addition. As such we propose the existence of a utopian or infinite number line with a zero square 0*0 on its inverse part.

§1.1.1. Signs

Variables are notated in lower case a,b,c,.. and can be replaced by numbers or by expressions reducible to numbers. The number substituted for a variable depends on the context – the parameters inside an expression of bigO are defined to hold natural numbers [n≥1] larger than zero.
When you choose to substitute another type of number, the justification for this is a special number theory.

A wildcard is written in upper case A,..,Z to hold the place of any word (sequence of characters) allowed on that position in the expression. Bear in mind that a wildcard can often also stand in for an empty string.
Wild card R (sometimes S,T too) is reserved to designate a row or part of a row of parameters. In the following definition for a partial row R with n non-zero parameters, the empty row is expressed when n=0.

The incrementor i is repeated in the corresponding ellipsis and incremented by 1 at each repetition.
The 3-point ellipsis ... is a wildcard for a sequence, specified by a meta-repetition statement X#Y that follows after the expression. A 2-point ellipsis .. can be used instead, and if a meta-statement doesn't follow this .. relies on the imagination of the reader to continue its series (usually there is a minimum of one item).
We notate repeating operator signs with a superscripted ellipsis ×... or ×..

An equation A=B or A=>>B states an exact reduction step of the left expression to the right.
An expression does not contain an equality sign = or an equal by iteration sign =>> or an approximation sign ~ or some comparison sign < > ≠ or substitution sign := or mixed sign thereof.

The inverse unit - generating the negative integers -*n is treated in the next chapter, as is omega ω.
Inverse units should be appended on the right n- of a number, to tell them apart from subtraction n-1.
Because we use e as a 5th function parameter and i more as an incrementing index, the classic signs e for the base of natural logarithms and i = √-1 for the square root of minus one, are written as ê and î = -^2^-
You can find more special signs in the Sign dictionary.

§1.1.2. Colours

Meta-expressions are notated in [violet] font. Both subscripts and meta-expressions preferably use star operator notation, with addition as zeroth star, e.g. [t_m1;≥ab] specifies variables a+b < t_m+1;

To typify individual variables, wildcards, etc. these are subscripted as: Sign,red,orange.;;

Old style expressions in brown font use the operators +,*,^,^^,.. and apply old school precedence.

Arrows and stars a^...b [^#m] = a*...b [*#m1] can be used to express super-powers. Both operations result in the same numbers, but the latter requires an extra star and there's the issue of precedence.

• Minority star operators have colour *.. black and define operatorial bigI.
• Operations with majority arrows ^.. navy are expressed by function bigE.
• Addictive plus operations +.. green are used in the construction of bigA.
• Sometimes an expression in a deviant context has the colour kryptonite.

To improve the readability of bracketed expressions we've painted nested entries in the colours of the sea.

Some more arduous (even tedious) samples from longer calculations are currently hidden in the web version of the book, but can be conjured up by clicking a dynamic link to show the grinder!
You can double click the online text to highlight (and print) memorable passages in yellow.

Your reading experience can be further personalized by selecting your own page, highlight and font options in the small form box on top of this webpage. The new settings are kept in a cookie on your browser.
Another interactive feature is the ability to hide (or show) parts of the book with the X close icon (or O open icon) at the top right of each chapter heading. A copy of the chapters of your choice (but without yellow highlights) is then kept in the New Page link that you can find (and click) above the main index. So you can share just the chapters from the book that you like by sending somebody a personalized link (this we recommend).

Note that printed versions of these pages may lack colour, but all the concepts visualized above can still be discriminated from the context.

§1.2.1. Indication

Meta-expressions in square brackets [] for substitution and repetition and in curly braces {} for set and class offer us methods to formulate rules for the evaluation of expressions.
A meta-expression [X] can determine the range of a variable or the length of a character sequence (a repetition of words) in the preceding mathematical expression. These notations will help to work out the reduction cascades of operatorial functions and to approximate their relative speeds.

The notation for the range of a variable is familiar, e.g. n>0 to exclude 0 from the natural numbers.
When needed a meta-statement marks the empty space betwixt variables – with 0_* to add (our default) or 0_^ to multiply (your fault) two neighbouring variables as a single number ab (this we discussed above).
A meta-expression contains a number m of meta-statements Mi which apply in order to preceding expression X.

To show which part of the expression the meta-statement applies to, we will either quote the intended character(s), or point to their . beginning and end . with inserted dots. As subsequences S can be quite long – the new rule saves on paper, but costs ink. (o: the legendary ink dots :o).
Dot selection is safe for expressions where surrounding A and Z may contain S that must not change. Indication of a subsequence by quotation in the meta-statement is literal (or lazy) by default, but can be made greedy. Where literal indicators substitute the character S exactly as such, greedy indicators also target adjacent S situated at the end of A or at the start of Z.

Usually series of meta-statements are evaluated from left to right – which is easy because it doesn't involve repeating as yet unresolved meta-statements – but when an ellipsis .. is itself repeated, a stricter order of precedence from right to left applies. Advanced meta-statements may refer to each other, so that two (or more) take turn in tandem.

Anything that either is or is not can be counted. Every recursion starts with a single operation, defined with an initial case and a single step. With bird's-eye view we can reduce any number of steps to a single meta-repetition.
We believe that, as the rules for the reduction of our Big number constructions become ever more complex, the meta-operator # for repetition will come to lead a life of its own. So that in the end, the whole hip hop movement between expression and meta-expression bursts open for #.. quantification.

§1.2.2. Substitution

Every construction is built from units and substitutions. This way we've defined multiplication a*b as a series of substitutions 1... [1#b 1:a] of the units 1 in a natural number for another natural number.
In essence all notation is substitution. Here substitution is first selection, the read – which requires recognition and physical positioning – and then replacement, the write – which combines the acts of removal and insertion.

Our meta-statement of substitution is A:B and more precisely A:B in P where the substitute word B replaces A on the receptor site A in the preceding expression or exclusively in part P of the expression.
The evaluation is given by XAZ [A:B] = XBZ and TPY [A:B in P:XAZ] = TXBZY, where all A in X and Z are included – recursively as X'AZ' etc. – but possible A in T and Y are excluded from the substitution.

In case substitute B is empty then XA [A:] = X removes site A recursively from each X'..A word.
On the other hand X [:B] on its own does nothing , because an empty site is normally not eligible for substitution. Any substitution rule n [:1] = n1 of zero, would lead to n1.. [1#ω] = ω a definition of infinity.
We'd rather use ω directly, and apply (:n) to the enumeration of characters in hyperarithmetic.

Just like multiplication, repetition of a word A by a whole number n can be covered by two substitutions A:n 1:A. This works for all A (for XAZ subsequences dot selection or the in clause helps).
Repetition by substitution embodies a distributive law, it doesn't raise issues when A.. [#n] ≠ n.. [#A] is not composed of (evidently) commutative factors, such as omegas (and zeros).

Vice versa you can notate substitution A [A:B] as repetition, by A...B [A#] which looks somewhat odd. The A left of the ellipsis will be selected for repetition by 0 and removed, so the B the tooth fairy appended is left. Nothing is actually substituted – what should have been a series was simply pulled out!

Though we use meta-repetition statements profusely, in our view substitution is the True Way, if only because it expresses   [0:1] = 1... [1#ω] = ω infinity naturally, where the raven of substitution would fly off to a rapacious .. [#1] = 0... [0#ψ] = 1 end of the world, if ever, to meet the initial One, or else wait nine days for Him to fall  .. [# 0_^] = 0^0 = 1 from the Tree of More remember?

§1.2.3. Repetition

We define a meta-notation for repetition, applied in mathematical and logical expressions.
By extending it with smart features this will be our main tool for constructing Big numbers.

We abbreviate a 3-dot ellipsis ... to a 2-dot ellipsis .. whenever this is convenient.
Superscripted ellipsis ×... count operators, e.g. 2^..3 [^#n] = 2*..4 [*#n]

Extend our meta-repetition notation to cover double-sided recursive constructions.

An expression AB.... [#m B..#n] with two 2-dot ellipsis .. is a power tandem,
where the right or second hash # repeats the ellipsis .. for the first, see example.

A full dimension box with repetitions m=n can be marked with a square ellipsis ::
Such power and tetration-like meta-repetitions should be evaluated from right to left.

§1.2.4. Variation

Reserve special meta-variables i,j,l,o to allow repeated sequences to evolve.

Incrementors i or j can be followed by an iterative ellipsis (or illipsis) .:. or :.
The :. indicates the sequence in which each preceding meta-variable is dealt with
(a telling example and a hard one with two incrementors handled by a single illipsis).
It is used to override the default where the first ellipsis after the incrementor owns it.

Also a series of substitutions can be employed to address meta-variables,
as in O(v,...) [v#n v:Xi] = O(Xi,...) [Xi#n]

Our choice to count fingers 1.. to finally represent Big numbers is not so primitive as it might look. For practical Big purposes its capacity is comparable to decimal numbers, even with exponential notation m.nE+p = m.n*10^p applied.
The principle of frugality then tells us not to waste characters on extra digits to support an inefficient number base (radix). Consider a moderate example:

A series of n ones can be noted down in log(n) digits, concisely so it seems, but already when n = 10^^10 = 10^... [10#10] no (exponential) notation based on an integer radix r>4 offers adequate storage capacity.

The resolution of finger counting is the same in every radix system – all natural numbers are covered.
Note that two natural numbers can represent a fraction n/m or replace a decimal point n.m

Do the binary power towers 2^^n = 2^... [2#n] increase by squaring and decrease by √ square roots?
Use the function lg below to refer to logarithms of 2, so lg(a) = log(a)/log(2)

With respect to a number made by tetration a^^b either squaring or adding 1 does not matter much to the result.
Apparently a system with a resolution where squares have meaning – physical measures are inconceivable without – does not have enough capacity to set most tetrated numbers 11***b and 11***b1 apart.

From a programmer's perspective the mathematical expression of a Big integer is input, formulated by two or more character types. The program itself simplifies this expression in several recursive reduction steps, which typically require extra bracket character(s). And the projected output is a number of repeats of just the digit 1.

§1.4.1. Our little universe

The information capacity of our physical universe was recently estimated by Seth Lloyd at 10^90 quantum bits. Any sequence of bits in a fixed state represents a number – this way the random number the cosmos embodies in an instant is ~ 2^2^299.
We can see no particular mathematical reason why there shouldn't be more information around. And indeed, Alan Guth's theories of big bang hyper-inflation provide for an exponential number of pockets of universes of which ours is only 1.
Whether the size of the larger mathematical physical substrate is unlimited, we do not know.

Fact is, we're stuck with Planck units, quantum particles and astronomical constants, which put a physical lid on the size of the information our universal laptop can process.
Suppose the cosmic processor calculates at a fixed rate of (2*(2*2)!)! Planck impulse moments per Planck time unit of 10^-43.2683 s. This algorithm results in a constant energy in the universe of 10^71.1835 J, which divided by Einstein's square of light speed amounts to 10^54.2298 kg approximately the observed mass in the cosmos.

Most information is packed in dark matter and stellar objects, humanity happens on the fringe of cosmic computation. We wonder, is intelligent life a kind of software corrosion, or are we quality – meant to be – on top of quantity?
If life is important so is ethical behaviour, if the universe is important so is religion. Operating on the edge of randomness and determinacy these bits of life cannot grasp and hold their own raison d'être.
On the other hand, this universe – which looks continuous but deep down is discrete – might be a virtual mirror of an earlier Real One, which numerically bugged the Gods called Great. Then what happened to our real selves?
And where are We all?_? In a cascade of Transcending importance?_?? [ write on :-]

According to Seth Lloyd the number of logic operations performed thus far is 10^120 ops. So a digital disk with a perfect copy of the universe up to the present day puts maximally 10^210 bit configurations in causal order.
This seems to convert ops from time to space, but the cosmic Planck grid counts only 10^60.9 time units up to now, and the laws of nature constantly zip up all quantum-events with a physical variant of Jpeg-compression.
Universe, earth, body and mind – all have limited resources. Use them wisely… (read on :-()

Somewhere after stars stopped shining, black holes evaporated and a Big Crunch rolled us all up, the history of the universe must end. We estimate the size of a total copy of cosmic history between 10^100 and 10^300 bits, expressing a random number below the ceiling of 2^2^830 ~ 2^2^2^10.
Left on its own the cosmos never will be able to express a modestly Big random number – for example of size 5^^4 ~ 2^10^2185 ~ 2^2^7257 ~ 2^2^2^13 – even though mathematicians know such numbers exist, in abundance… (this is a proven theory, called the frivolous theorem of arithmetic :-)

Because we can easily express very Big numbers by iteration of functions, Big physical number holes are gaping in-between, where random natural numbers hide which are inexpressible given the resources of our universe.
Big random numbers are physically infinite and cryptographically safe for alien computers (that's a promise ;-)

The sole way to address random Big number individuals, hiding in physical infinity, is by chance [or prayer ;-]

§1.4.2. Chance functions

Just as numbers can get astronomically large, extremely small chances surely exist. This is lovely – you don't know anything that can happen in the real world with 100% certainty. Perhaps your eyes were deceiving you, perhaps someone's memory was incorrect. Small chance? Ask a forensic expert!

Small chances make bad statistics. To win the jackpot in the state lottery 10 times in a row (buying a single ticket for each draw, without using your mafia connections) is less probable than being the first man to have set foot on the moon (when your name isn't Neil Armstrong. Don't you remember? It happened when you were three: the Russians abducted you, they came there first, the American moon landings were staged, as are the Chinese.)
Write a scenario, dissect it and multiply the probabilities of each separate event. When you thought of everything and your estimates are right, the resulting product is a lower bound for the total chance, because events tend to correlate and other scenarios are possible too. (This proves the number of connectable events in our world is vastly limited.)

To express truly Small chances, we have to refer to processes that can only happen outside of the physical guya of our universe. The proposition that we all live in a yellow submarine which entered a black hole and came out in one piece on the other side, except that your intestines are inside out (of which you'll become aware in about 3 seconds), qualifies with a Small amount of uncertainty as wrong.
Yet it's infinitely more likely than the construction of a spaceship powered by an Infinite Improbability Drive somewhere in the unknown future. But then we're talking infinities, and zero chance.

To say that the number of 9^^^^^^^^^9 ones shall be reached one day on your computer by click starting the series 1.. (multiple clicks allowed!) and then just letting the program roll out, in our opinion is harder to realize then the aforementioned world inside a submarine.
It belongs in the Guinness Book of Records as the Smallest non-zero chance to date practically conceived by man.

Nature is random, therefore it's essential to be able to express random numbers and their probability.
We propose these elementary functions of chance.

There's more to counting than meets the eye. In the real world for instance, it's not obvious when we have counted all the objects we have. Maybe later more items will be added, counting is a process, it never stops (though it doesn't really reach infinity).
Therefore a more philosophically inclined mathematician would consider all the natural numbers to be lower bounds. And he would raise his arithmetical system up from this experiential fact of counting.

We'll re-employ the plus sign as a unary operator + acting as a count on a left operant. This new +0 is the initial case of a whole family of countable unary operators +c culminating in the operatorial bigA.
We'll name these operations addictive (Latin addictio = assignment).

The start of + is 1 is familiar, there's this given number a and we count one more.

The next step, operations with subscripts +1 results in doubles, of doubles, of…
Then ai+1;.. ... [ai:2? +1;#i≥0 #n] expresses integers in a random binary system.

The basic formula for left associative operators +c has the same footprint.

Inverse addiction +- is a strange beast – it does not exist (or inexists).

More on addictive subscripting in chapter 3.
Our main story line continues with super-power star operators in chapter 2.

§1.6.1. In Egypt, India and Greece

From the days of Egyptian hieroglyphs to Indian decimals to Renaissance exponentiation our ability to express numbers in a concise manner has evolved.

Of course the Egyptian numerals look differently, but they were millennia ahead of their time – using powers of ∩ = 10 as a number base, counting units instead of exponents, character typing powers instead of digits.
The hieroglyph of the worshipper unit on the right signifies the megalithic figure of a million, as well as infinity.

These signs for 1 10 100 1000 10000 100000 1000000 are at least five thousand petalled lotus years old, as the last three are inscribed on the macehead of the possessive Pharaoh Narmer of the first dynasty.

Some 3000 years later in zero-minded India the mahâyâna (Great Vehicle) buddhists developed a big thirst for stupendous baroque visions of the universal Buddha and the unspeakable numbers to count his huge host of followers and his manifold virtues in a library full of scriptures of which the most renowned is the Lotus Sutra.

Meanwhile in Greece the musings of the mind became more mundane and Euclid wrote his mathematical masterpiece Elements (300 BC) of which his foundation of geometry and in particular his postulate for non-parallel lines is best known because it gave rise to non-Euclidean geometry.

From Archimedes of Syracuse we have a treatise called The Sand Reckoner, where he calculates the maximum number of sand grains 10^63 that fit inside Aristarchus of Samos' heliocentric universe (diameter ~ 2 light years).
Archimedes knew the law of exponents a^m*a^n = a^(m+n) to manipulate powers of ten.
Then it's easy to derive the second law (a^m)^n = a^(m*n) too.

The largest number of Greek antiquity was Archimedes' 10^8*1016 ~ 944 TB
Terabyte computer hard disks nowadays write away: 1 TB = 2^48 bit

§1.6.2. Untold number records

The largest and most grandiose work of buddhist literature is the Flower Ornament Sutra (Sanskrit: Avatamsaka Sutra, India 2nd century AD). Chapter 30 The Incalculable (Sanskrit: Asamkhyeya) describes the largest numbers in ancient history, but experts disagree on their exact size. The three major translations calculate a series of squares differently, resulting in different uncountable numbers.

The first Chinese translation by Buddhabhadra starts credibly by squaring the induction base x₀=10^5 (Sanskrit: a Laksha). The second translation by Shikshananda is the more complete text and has a series of n=103 calculable squares. We propose the incalculable Asamkhyeya is reached at x₁₀₄ by applying our squaring formula.

Note that Cleary's translation (which generally follows Shikshananda who starts squaring at x₁ = 10^7) positions his induction base at x₀ = 10^10 one square higher than Buddhabhadra. But on top of that he has 10 cumulative mistakes and 8 copying or printing errors, so Cleary's last calculable number at x₁₀₃ is not accurate anyhow.

Philologically, the question why x₁₀₄ = 10^(5*2^104) is out of reach in buddhism is of special interest.
During the traditional practice of mantra meditation a monk keeps count of his prayers with rounds of 108 beads on his rosary. Past 108 there is no counting – exposing a hidden property of that foremost uncountable number.

The Buddha continues with a series of squared squares, that define the numbers measureless x₁₀₆, boundless x₁₀₈, incomparable x₁₁₀, innumerable x₁₁₂, unaccountable x₁₁₄, unthinkable x₁₁₆, immeasurable x₁₁₈, unspeakable x₁₂₀, untold x₁₂₂ and finally square untold x₁₂₃.
Use our squaring formula to find the values of the Avatamsaka Sutra's countless numbers, e.g. the unit untold x₁₂₂ = 10^(5*2^122) on which even higher number records are based in the following verses [vs.2-3].

"If untold x₁₂₂ Buddha lands are reduced to an unspeakable x₁₂₀ number of atoms in an instant,
and in every single atom are untold x₁₂₂ lands..."  = 10^(45*2^120) ~ 2^2^2^7
"...and this continuous reduction propagates for untold x₁₂₂ aeons, then it's hard to tell their number."

Thus the exact number record of the ancient world is defined as 10^(45*2^120) universes.
The rest of the numbers in the story can only be estimated, and is subject to speculation.

Though it's historically unclear what an instant is, this question can very well be solved by modern science, which says there are 1.855E+42 shortest instants of Planck Time in a second, a total of 10^47 moments a day.
Our aeon can be defined as the maximum period for life to exist in the universe, which is probably until star formation stops after 10^14 years. Then there are a maximum of 10^17 days in an aeon, and a total of 10^64 moments.

In chapter 31 of the Avatamsaka Sutra called Life Span, every aeon in the field of a Buddha is equalled to a day and night in a higher Buddha world. The number of moments t_r in a Buddha's aeon is increasing at each reduction level r of lands. Our instant land formula calculates the exponential number of worlds w_r issuing from a level r Buddha land, where w₀ is the minimal field of Shakyamuni Buddha, our stellar universe.
The constant u is the number of universes resulting from one instant of reduction of all the atoms of a Buddha land, where u = 10^(25*2^120) is as quoted above.

Let the reduction start in a Buddha land where the aeon consists of untold x₁₂₂ instants, then we derive from t_r its level r ~ 2^120.3 and the number of worlds issued from its atoms w_r ~ 2^2^2^126.
The next reduction level r-1 will result in a total of w_r^2 lands and so on, all the way down to the atoms of level r=1 as the last Sutra quote suggested. In this continuous reduction the physical coefficients of t_r in our instant land formula don't matter much – only the extra exponent does – and the effect of the constant u is negligible too.

Still the estimated total number w of Buddha lands appears immovable like Mount Sumeru. A power tower 4 storeys high is the boundary of human imagination, the machinations that follow lie beyond the veil.

Exponentiation (raising to a power a^b) is the operation which iterates over multiplication. We'll prefer the double star** here rather than the arrowhead ^ to use as exponentiation operator.

Next comes the true super-power of triple stars *** which Goodstein called tetration (tetra = 4) counting index 1 for addition (here 0 stars).
Our triple stars equals two ^^ arrows (arrowheads) and adheres to Donald Knuth's 1976 up-arrow notation (where the operant b always counts repetitions of items a) and not to Ackermann's phi recursion (because Ackermann's own iterator b counts the number of in-between operators instead).

The insight that * is a countable unit, dawns with the recognition that operators *.. can be expanded at will.
Of the various names for this family of operations that have been suggested, Nick Bromer's superexponentiation is most instructive. Note the super-exponential star operation isn't really built upon exponentiation a**b which is the 2nd operation in a series starting with instant addition as initial 0th.
On second thought Bromer's term is visually and verbally overweight – we'll use our super-powers instead.

An n1 number of super-power stars in a*...b equals n arrows in a^..b.
But there are differences with respect to their order of evaluation or precedence in complex expressions. With competing star operations a*..b*..c smaller operations with less stars are evaluated before larger operations (without brackets). This we call minority precedence, contrary to the majority precedence you're used to since primary school, and which applies to the arrow operations of a^..b^..c
In expressions where both stars and arrowheads appear, arrow operations always take precedence and are resolved first. Types of precedence are further investigated in chapter 2.4.

To show off with our new super-powers, we calculate a few pentation squares m^^^2 and conclude with a more general tetration approximation rule, where ~> is the sign for an algorithmic successor.

The initial super-power star rules are addition at c=0 and the case a*1 = a.
Next operations *.. are recursively =>> defined, so that every reduction train stops at the initial case.
The basic super-power formula provides for a countable number c of stars.

• a*^...1 [*#c1 c>0] = a*^...1 [*#c] =>> a*1 = a
• a*^...11 [*#c1] = a*^...a [*#c]   so 2*^..2 = 4
• a*^...b1 [*#c1] = a*^...(a*^...b) [*#c *#c1]
               =>> a*^.. ... [*#c a#b1]

§2.0.2. Backslashes

The approximation of Big number algorithms often benefits from a precision notation with backslashed operations H\×..g that assigns a lower level operation (the guest) to a higher (the host). Here the backslash \ invites a guest operator ×.. with operant g on top of a host operation, such as H = a×..b [×#c]
The backslash is dropped when the host has fully counted down a single operator sign, as in a×.. ...(a×..g) [×#c- a#b-] where the guest joins in with a direct (bracketed) evaluation at the assigned (top) position.

We've pondered the virtues of backslashing, and below you'll find a few instructive examples.
Star operations *.. are resolved by minority and arrows ^.. by majority precedence.

The original backslashed operations stay unresolved, but as soon as the host has shed a single star – for backslash virtuosos ~ as many stars as we count off backslashes – the activated backslashed operation is granted the highest priority. Then these are evaluated from the inside out.
Subscripted backslashes \n count from 1 to n, but may do this in two directions. So that g*\n;a^^b counting up from left to right, and a^^b\b1(-*n);*g from the right down, apply to the same nth exponent a in the host.

§2.0.3. Beyond logarithmic senses

This subchapter zooms in on tetration and super-powers. Skip the details if your interest is to get the Big picture.

We compare expressions of the form (a*..b)*..c with the form a*..bd and try to see what lies beyond.
Mind that  1\b;a^^b1 < a^^b1\1 = a**...**a1 [a#b] < a1^^b1  puts the backslash notation we've just invented to good use.

• (a*b)*2 = a*bb  is a case from:
  (a*b)*b = a*b^2  from:
  (.a.)*b.. [#n#] = a*b^n
• (a^b)^2 = a^(b*2)  from:
  (a^b)^b = a^b^2  from:
  (.a.)^b.. [#n#] = a^b^n
• a^^b1  =  a^a^^b <~
      (a^^b)^^2  =  a^(a^^b-*a^^b) <~
           1\_3;a^^b1 [b>2]  =  a^a^a1^a^^b--  from:
• a^^bb- <~
      (a^^b)^^b <~
           1\_b1;a^^bb-  from:
• a^^bb-.. [b-#n-] <~
      (.a.)^^b.. [#n#] <~
           a^^1(n*b-)\_b--;1

From 3 arrows onwards these expressions are exceedingly difficult to resolve. It can be guessed from these comparisons that our minimal range for pentation ^^^ is already very imprecise, if not lost in jeopardy.
We look at the case for b=2 starting at a=3, where a widening number hole is looming.

We'll boldly generalize our findings in a super-comparison formula of super-powers.
In the cases below let ^.. [^#c c>2] and its reduction *.. [*#c] continue from where we left, after tetration. Mark the specified repetition dots ... violet. As usual arrows take precedence before stars.

• a^^..b1  =  a*^..a^^..b <~
      (a^^..b)^^..2  =  a^^..b*^..a^^..b  <=>
• a^^..bm  =  a*^.. ...a^^..b [#m] <~
      (a^^..b)^^..m1  =  a^^..b*^.. ...a^^..b [#m]  =>
• a^^..(b-*n)1 <~
      (.a.)^^..b.. [#n#] <
           a^^..b*n      .

§2.0.4. Primitive recursive family

We'll first explain what recursion is and what primitive recursion, and how all super-power stars *.. can be created just by primitive recursion. This answers to the meta-mathematical need to classify a function according to the simplest means that generates it.

As an example we'll generate a primitive recursive function family Fac, which is a bit special because we start with a function index -1 where 0 is more common. Fa is faster than star super-powers, by Fac(a,0) = a instead of a*..0 = 1 [*#c c>1] so that for example Fa2(a,1) = a+a*a
The inverse unit is used to signify both the negative index - = -1 and subtraction as in a- = a-1. For an explanation of the applied list markers, check chapter 4.

• Fa_-(a,0) = 1
• Fa_-(a,b) = Fa_-(a,b-)1 =>> 1... [#b1] = b1
• Fa_c(a,0) [c≥0] = a
• Fa₀(a,1) = Fa_-(a,Fa₀(a,0)) = Fa_-(a,a) = a1
• Fa₀(a,b) = Fa_-(a,Fa₀(a,b-)) =>> Fa_-(a,..a.) [#b#] = ab
• Fa₁(a,b) = Fa₀(a,Fa₁(a,b-)) =>> Fa₀(a,..a.) [#b#] = a*b1
• Fa₂(a,b) =>> Fa₁(a,..a.) [#b#] = (a**i)... [#b1 0_*]
• Fa_c(a,b) = Fa_c-(a,Fa_c(a,b-)) > a*^...b1 [*#c a>0 b>0 c>1]

Family Fac could very well have used one rule Fa0(a,b) = ab for initialization. Then only two axioms would have sufficed to define Fa, one less than super-power star or arrow operations.
The reason why Fa didn't make it as a defining algorithm for super-powers is that its properties are not so cool as those of multiplication, etc… Because a*b = b*a is commutative and Fa1(a1,b) = Fa1(b1,a) is not.
And although the virtues of exponentiation a^b are distributive, with a minor adaptation using logarithms the powers can be rendered commutative by a^(log(b)*e/log(e)) where e is an arbitrary exponent / base.

§2.0.5. Ackermann's jump from primitive recursion

Ackermann used a primitive recursive φ function (phi) as a prerequisite to construct the higher level Ackermann ψ function (psi) in his article "On Hilbert's construction of the real numbers" (1928).
The Ack_φ (φ) function is a super-power algorithm, it differs from star operations only with respect to the initial cases for operators c>2. After that it grows away slightly from super-powers, though Ack_φ never catches up with the upstart super-power function family Fac which raised its initial case earlier at Fa1(a,0) = a

• Ack_φ(a,b,0) = ab = a+b
• Ack_φ(a,0,1) = 0
• Ack_φ(a,0,2) = 1
• Ack_φ(a,0,c) [c>11] = a (Ackermann's extra axiom)
• e.g. Ack_φ(a,1,11) = a
•      Ack_φ(a,b,11) = a**b
•      Ack_φ(a,1,111) = a**a
•      Ack_φ(a,b,111) = a***b1
• Ack_φ(a,b1,c1) = Ack_φ(a,Ack_φ(a,b,c1),c)

If you'd replace the 2nd and 3d rule above by a single axiom Ack_φ(a,1,c) [0<c<3] = a the evaluation of all expressions of Ack_φ where b>0 will work out fine.
Compare the relative speed of the super-power functions from this chapter. The three of them are relatively close, with differing values of b, while arrows a^...b [^#c] increase a unit value of c faster than stars.

• a*^...b [*#c c>11] < Ack_φ(a,b,c) < Fa_c(a,b) [a>0 b>0]

We still owe you Ackermann's historical psi-function which gave rise to the concept of the Ackermann numbers. The whole Shakespearean purpose of Ackermann's Ack_ψ (ψ) function was not to be primitive recursive, which succeeded gloriously. Yet there was no mention of any Big numbers in Ackermann's famous article.

• Ack_ψ(a) = Ack_φ(a,a,a)
• Ack_ψ(i) =>> { 1, 4, 3^3^3^3,
                 4^^(4^^(4^^(4^^5+1)+1)+1), .. }
• ψ(4) = φ(4,4,4) = φ(4,φ(4,3,4),3) = φ(4,φ(4,φ(4,2,4),3),3)
       = φ(4,φ(4,φ(4,φ(4,4,3),3),3),3)
  φ(4,4,3) = φ(4,φ(4,φ(4,4**4,2),2),2) = 4**4**4**4**4 = 4***5

The complications in working out the structure of the 4th Ackermann number seems to prove that his extra axiom is apart from being unnecessary also relatively unnatural. Of course this depends on our view of naturalness, which is tainted by Donald Knuth's up-arrow type of super-powers. The cumbersomeness of defining extra axioms is not a strong argument in this discussion, given the leaner physique of Fa with its meaner power operation Fa2, which is just as unwieldy as a translation of Ack_ψ(5) to arrows – try for yourself.
Anyhow, without the extra axiom the resulting φ' function has the same rules as the super-power stars of bigI. And the expression Ack_ψ'(4) reduces to 4^^^4 = 4^^4^^4^^4 more straightforwardly (in our eyes ;-)

§2.1.1. Unit -

Notate new style negative integers as repetitions -*n = -.. [-#n] of inverse units.
The inverse unit - can be defined destructively as follows, in star context, also with the complex root î = i

• -1 [0_*] = 0 (successor is zero)
• -*- = -**11 = 1 (square)
• (a*b)(a*c) = a*(bc) (left distributive law)
• 1- [0_*] = (-*-)(-*1) = -*(-1) = -*0 = -.. [-#0] = 0 (add right)
• î*î = -

When we allow negative integers as values of iterators, arithmetic is already enriched with division, square roots, etc. There are many iteration operators, so the mathematics of inverse functions is an abundant topic.
The elementary inverse sets comprise the negative, the rational and the algebraic complex numbers.

Even though their real world approximation might well require infinite series, inverse numbers can be represented exclusively by countable units {1,-,*} and in this (notational) sense all inverse numbers are countable numbers.

The two inversions of super-powers can be represented by a multiple division sign /.. for super-division (division, roots and super-roots) and by a new binary operator £.. for super-logarithms, functioning as you would expect from conventional logarithms.

• (a/^..b)*^..b [/#c *#c] = a = (a*^..b)/^..b [*#c /#c]
• a^^..(a£^..b) [^#c £#c] = b
  with a£b = ^alog(b) = log(b)/log(a)

Perhaps a super-modulo operator %.. is helpful too, but you won't see many inversion signs in this article.
The int function yields the integer part of a number, so that int(2.7) = 2 and int(-3/4) = 0

Beyond exponentiation little is known about the super-roots /// and super-logarithms ££ of super-power operation *** and beyond. We can speculate that every super-power creates new sets of inverse numbers by combining earlier sets with the inverse unit - in various equations.
A mathematician who can pave the way for such inverse super-powers surely has Napier's bones.

§2.1.2. Unit ω

The first number that cannot be reached by finite counting is the natural infinity ω called omega. Georg Cantor invented omega to count (or name) the denumerable infinite set of all natural numbers.
By definition the unit ω is larger than any number expressible by recursion over the units 1..

Starting from the above order relation on omega and counting further with his infinite numbers (ordinals), Cantor travelled into the realm of countable infinity (Cantor's paradise) and never came back…
We'll declare ω to be the first unit of infinity and apply ω in place of 1 to express much Bigger infinite numbers.

Only when our operatorial expressions fail to reach higher a second infinity ω2 comes im Frage.
So an infinitorial function bigOmega can be defined, where Ω(1) = ω and Ω(n) = ωn and we can see that the road from Ω(0) = 1 to for example Ω(1,1) = ωω never ends, but does have a beginning.
It's the beginning that's special – and that is why our natural reality is probably virtual, some game designed higher up – and primitive mathematics is actually real and most important… ;–)

Concerning the domain and range of limits for super-power functions as b tends to infinity – Euler's thematic ê in the minimum and maximum of *** captures our imagination and helps us derive the power twins.

An exciting problem is whether the inverse values of function counter c naturally classify recursive algorithms. The rational number c=11^- for instance should be the operation halfway between addition and multiplication, but what does that mean?

§2.2.1. Transcendental numbers

Transcendental numbers are defined to be those real numbers, which are not algebraic. Algebraic numbers give the solutions (roots x) to polynomial equations, which are composed of addition, repeated multiplication, constants ai and an unknown variable x.

All polynomials with exponents 0<n<5 are solvable by radicals, but most higher polynomials n≥5 cannot be simplified, as Galois (1832) showed. For example, the quintic 2*x^5 + 5 = 10*x is not solvable (Abel 1824), though it has 5 roots.
While the defining polynomial of an algebraic number is enumerable, often that equation cannot be reduced to a simpler expression. Of course its x can always be approximated by iterating over some continuous algorithm…

Generally, for any class of functions there are numbers which cannot be expressed by recursion alone, but which must be created by mixing and inverting existing operations. And then there are higher transcendent numbers that escape any such definition and can only be approached by infinite recursion.

With the expansion of the function context many former transcendental numbers run the risk of finding expression. In the box below we utter our doubts about pi π. Together with π a host of connected constants may fall from infinite grace. Foremost ê, the base of natural logarithms, which is connected to π via Euler's famous theorem.

§2.2.2. Transcendent numbers

We've elected the term transcendent for numbers which cannot be defined within a certain class of functions under inverse composition (compare the polynomial composition above, which exploits the algebraic inversion of the function class up to multiplication optimally).
Our recursive operatorials bigO travel well beyond the algebraic realm, so the inverted transcendent numbers that escape the net are a far more elusive set than the common transcendental.

Real transcendent numbers are supposed to be based on ω, for they can only be defined by infinite iteration.
We assume the majority of all numbers to be really uncountably deep, but appear helpless in constructing one…

All in all it's unclear whether transcendent units can be sustained.
There's always hope to rediscover each real constant by clever use of finite recursive algorithms (in the future). Yet the more advanced our mathematical functions, the more elusive the transcendent numbers that can be generated by application of these functions to infinite series.
So if transcendence isn't here to stay, it seems the continuous generation of transcendent numbers will never stop …flowing in ever wider streams towards finite solutions on ever higher levels. A truly infinite phenomenon!

The larger the numbers we'll come up with, the bigger the holes in between where random numbers hide, that cannot be expressed because we lack the physical resources. Even if all the quantum-information in our universe could be deployed to write a single integer with a single arithmetical algorithm, most Big integers would escape the net.
The image this conjures up in the mind of the observer is that of an expanding mathematical universe of galaxies of numbers, surrounded and dominated by dark matter which randomly falls down from infinity…

The earthly boundary for random information holes is at present given by Google's server size and time.
Google's current 10^18 bit will have to miss almost all integers smaller than a googolplex or 10^googol or 10^(10^100) and larger than (10^100)^(10^32) this year, no matter how sophisticated their algorithms.
Here's why:

Define a finite algorithm to be a text (containing expressions with variables), which is theoretically reducible to a single number when non-random values are substituted for each variable. Expressions are theoretically reducible, when we may work them out instantly in a hypothetical universe with infinite resources.

In a physical space s an algorithm can be applied a t number of times, but in a notational universe the time factor is part of the number p of available places, so that s*t = p.

To avoid doubles altogether, radix k can create unique (but smaller) numbers directly and without the fuzz.

State the Big number hole theorem of algorithmic oblivion.

To illustrate the theory, with 10^90 bits you can naturally express any binary number below 2^2^299. Suppose you use the first bit as a switch to a Big number algorithm, then you lost half your options 2^(2^299-1) and it is too hard to make up for it… If there are two choices in our universe, it is that expensive to pick one to apply.
<!- And that is why true Saints refrain from choosing – they follow the great Tao, walking the middle path… :->

At such Big heights dwell number sequences, packed with dazzling amounts of digital information – which ordinary man can never touch, for he is only allowed to express the very simplest of the words that go beyond this world.
This reveals the limitations of the operatorial methods you'll meet in this book – given the resources of our universe the Big numbers we can produce are nothing but tiny specks of extremely low information. A sobering thought.

§2.4.1. Right minority and majority operators

Star * and arrow ^ operations are right associative, evaluated while moving from right to left.
The various operations +,*,^ of the old school reduce in the same direction.

Star associativity looks familiar, but our use of minority precedence for these operators *.. differs from the majority precedence taught at school and applied to the classic arrowhead operators ^..
The rule of minority precedence compares neighbouring operations (those that share an operant), so that smaller or equal operators must be evaluated before larger operators. Same example:

The main advantage here is that we don't need extra brackets to further reduce the result of the operation. Usually after an operation is addressed for evaluation, its reduction takes place within brackets.

Donald Knuth's up-arrows continuing as majority arrows ^R;.. will overrule the minority nature of stars *S;.. so that in complex expressions a mix of * and ^ operations can be used instead of brackets.
The mutual precedence order of these super-power operators is illustrated below.
At the factorial precedence position ( ! other unary operations also take place, but units come first, such as number units 1.. which are joined by default.

In the formula for right minority stars the precedence function G will eat away expressions from the inside out.

§2.4.2. Operator comparison

Binary precedences in general work by scanning back, comparing former operators n to the latter m, until a pair of operators is found, which fulfils the precedence's comparison rule. Then the former operation of n will be evaluated, and the procedure can start again.
In the case of right minority precedence, scanning back to the left, the comparison rule [n≤m] demands that for a right operator n to be evaluated, it must be smaller than or equal to the operator m on the left.

Given right associativity and that we only compare for operator size, 7 distinctive types of precedence for binary operators can be put in the following order. For left associative operators the signs < and > should be reversed.

Minority precedence [n≤m] results in the biggest numbers of all 7 types of comparison, because the highest operators will be served the fattest operant values.
We have right associativity (straight evaluation n=n) as a good second, the rest is trailing. Try them on expressions like "2**3**2*2**3", we still need more statistics! [above order was a wild guess :–]

The human approach would be to pick out the smallest operators and resolve them first. An expression ruled by right minority precedence can then be seen as subdivided by its larger operators waiting to be resolved – which appeals to our intuitive notion of larger vessels containing smaller ones – with addition at the bottom, corked in a bottle.

A series of number units such as ω1.. must be added right associatively.
In the context 0^ of countable arrows a^...b [^#0] the operation with zero operators is multiplication, and addition may not be represented by any number of ^.. operators.
If we place variables a b next to each other, there is (by definition) no operation happening within the universe or context where the operator rules. There ab fuses to become one entity – a single number – until a simpler context is taken into account.
In the context 0* of minority stars the principle is clear – addition simply joins two natural numbers 1..1.. While in arrow context 0^ two qualities or quantities ab are joined directly, adding needs an awkward new old rule.

For quantities the prospect of such instant multiplication looks grim, but for the mathematical qualities of the units {1,-,0,ω,ψ} there is hope. Does it help us to obtain division by zero, the Holy Grail of the Dudes? Try me!

• 1^^-^- = 0^- = 1/0 = ψ (our utopian unit psi)
• 0.. [#ψ] = 0*ψ = 0 [0:ψ 1:0] = 1.. [1#ψ 1:0] = ψ [1:0]
           = 0^1*0^- = 0^1- [0_*] = 0^-0 [0_^] ~ 0^0
           = 0/0 = 1.. [1#n<ω] ~ 1

§2.4.3. Various unbracketed

The lifespan of a pair of common fixed brackets is regarded as eternal: ( = (ω
On the other hand some parts of an expression won't need bracketing: (0 = (.. [(#0]

With unbracketed evaluation the operants issued by intermediate reduction steps are allowed to drift away and attach to neighbouring operators before the original operation has been totally reduced to natural number. After each partial reduction the whole expression should be evaluated again right associatively from the outside.
Here we'll mostly apply plain unbracketing (0 which directly removes fixed () brackets from some given formula.

Imagine a type of temporary brackets (s that last for a variable number of reduction steps #s within the reduction train that carries them (steps from other operations, outside or inside these particular brackets do not count). The last reduction included in the cascade of s is the step to an iterator value b=1.
Brackets (r with remaining steps r<1 are to be dropped from the expression before their contents has been evaluated, after which the usual precedence of the operators prevails. Brackets (r where r≥1 stay fixed after the original reduction train has past, until their contents is resolved to a number (as usual).

Write the formula for Right/Left associative minority/majority exponential star operators with (s brackets that count off the most primitive of steps.

• Rm/m: (_s;a**b1) = (_s-;a*(_s;a**b)) = (_s--;a*(_s-;a*(_s;a**b-)))
               =>> (_r;a*..(_s;a).)  [#b#] where r = s(-*b1)i
• Lm/m: (_s;a××b1) = (_s-;(_s;a××b)×a) =
               =>> (_r;..(_s;a).×a)  [#b#] where r = s-b-1+i

Put step countdown s=0, so that after the applicable rule has been processed the brackets (0 are dropped. In the above formula this will work out to two or three different results (and one irreducible expression, running to infinity).
The first case Rmin of unbracketed minority stars *.. is overall slower than arrowheads ^.. and hereby is determined that this unbracketing is less powerful than 1 extra operator counted by c.

• (₀ Rmin: a*b1 -> aa*b -> (.a*2).. [(#b#*2)] = a*2^b
           a**b1 -> (a*a)**b -> (.a**2).. [(#b#**2)] ~ 2^^b\^a
           a*^..b1 [*#c1] ~ 2^^..b\^^..a [^#c1 ^#c] < a^^..(b+1) [^#c1 a>2]
• (₀ Rmaj: a^(b+1) = a(a^b) =>> a.. [a#b1 0_^]
           a^^(b+1) = a^a^^b =>> a^.. [a#b1]
• (₀ Lmin: a××b1 -> a××(b×a) ↑ ω
• (₀ Lmaj: a××(b+1) = (a××b)×a =>> a×.. [a#b1] = a^(b+1)
           a×××(b+1) = (a×××b)^a =>> a^(a^b)

Compare (0 Rmin with the unbracketing of a similar function Fa to match bigA's addictive pluses in chapter 4.2.
When a right minority operation is unbracketed, the item operant a of the largest operator is expanded, so that the numbers produced become Bigger. This is shown below for exponentiation – with larger operators differences like these tend to increment absolutely, yet become algorithmically less and less significant.

• a**b1 = a*(a**b) < a*a**b = a**bb
• a*^..b [*#c] < a*^..a*^..b- [*#c- *#c] < a*^..bd [*#c c↑ω d↓0]

We hereby close this exercise of unbracketing subscripted brackets, which is in the form where it counts off every single step (as defined above) a rather tedious tool – similar to subscripted backslashing. However, with these we can express Big numbers that would otherwise be lost in the black hole of inexpressibility.
Perhaps our surgical Big number tools could be put to better use, where each pair of brackets subdivides a larger number of steps in one go. Such as when a whole level of iterators is counted down in some nested surge and then a feedback operation ripples through…

John Horton Conway considers his greatest mathematical discovery to be the surreal numbers that he constructed by playing Conway games to fill in the gaps between Cantor's ordinal numbers ω1..
Another achievement of Conway is his popularization of Big numbers in "The Book of Numbers" co-authored by Richard Guy, where Conway shoots off a chained arrow notation ai→... [ai#n] which (for chains with n>3 parameters) names natural numbers far beyond the reach of super-powers and Ackermann's Psi function.

Conway modelled his chained arrows after Donald Knuth's up-arrows, introduced before as the arrow operation a^...b [^#c] starting from multiplication at c=0, then exponentiation at c=1, tetration at c=2, etc.
The principle that every next super-power ^.. [#c1] is equivalent to a repeated number of preceding operations, is with Conway's chained arrows expanded to an arbitrary number of parameters.

Conway and Guy's book doesn't tell what should happen with the single chained arrow a→b.
This is commonly interpreted to signify the powers a^b (plausible, for then all R→1 = R). But can also be defined independently as multiplication ab [0^] (else reduction to a→b→0 is unreachable), or as addition ab [0*] maybe (because it's missing).

Conway's formula for the first row of chained arrows covers super-powers, making a separate axiom for the basic 3 parameters unnecessary. We'll support the historical interpretation of a→b→1 = a→b to equal exponentiation, and let this 2 parameter case be the initial axiom.
Lo and behold! Here come the first 4 parameters of the archetypical operator function known as chained arrows.

• a→1 = a
• a→b1 = (a→b)a [0_^] =>> a... [#b1 0_^] = a^b1

• a→b→1 = a→b                a→b→c→1 = a→b→c
• a→1→c = a                  a→b→1→d = a→b
• a→b1→c1 = a→(a→b→c1)→c     a→b→c1→d1 = a→b→(a→b→c→d1)→d

We've presented Conway's notation in the same format as our operatorial functions (see bigE), to make clear that chained arrow signs → are more like parameter separators , than like operators. Normally operations are resolved in order of precedence, that is by operator size, but the evaluation of variables separated by chained arrows is the sole consequence of their position in the row, much like parameters in a function.

§3.0.2. A single operator subscript

A natural alternative to bridge the conceptual gap between operators and functions is to create operator types with coefficients in the form of subscripts. Subscripted arrowheads are recursively enumerated operators of a type which transcends super-power arrows.
We show the initial cases and steps over operator counter c and type counter d of subscripted arrows with 4 parameters.

• a^_1;b = a^^...b [^#b]
• a^_1;^...b [^_1;#c1] = a^_1;^.. ... [^_1;#c a#b]
• a^_d1;b = a^_d;^...b [^_d;#b]
• a^_d;^...b [^_d;#c1] = a^_d;^.. ... [^_d;#c a#b]

At the very start operator subscripts are equivalent to chained arrows, but when a>2 we promptly speed away.
In the example below, we conveniently use the signs 2 and 3 in place of their representation in units 1..

This should give you an impression of the respective strength of these notations.  
Note that in our construction of subscripted majority arrows ^Rj;.. a sequence of operators with mixed subscripts such as a^1;^b does not make sense yet.

§3.0.3. Passing a row of chained arrows

After the first 4 parameters the rest of Conway's chained arrows follows easily.
Let the wildcard R substitute for a row of arrow→separated→parameters of arbitrary length n>0.

• R→1 = R
• R→1→z1 = R→1→z =>> R→1→1 = R
• R→y1→z1 = R→(R→y→z1)→z

Because a→b = a^b there are no restrictions on the range of values the two drop axioms apply to. And the main axiom without condition y>0 implies that R→0→z = 1 (true as early as exponentiation). Fits like a clockwork!
Interestingly, the right part of a row L→1→R =>> L→1→y→1 = L→1→y = L collapses on the position of the parameter value 1. This is a waste of expressive power or resolution, for only the left (non-empty) part L is kept.

It's a bit awkward that we can't count down the last parameter z to 0 which is the preferred initial index for our operatorial functions. We'll define right arrows → with this operatorial countdown property below.

Now put Conway's chained arrow notation in φ-function format.

• Car_φ(a_i,...) [a_i#n] = a_i→... [a_i#n]

Conway went further as he hinted at a ψ-function or super-chained arrow, by describing the first 4 values of Car_ψ in his imaginative Book of numbers. The concoction of a double →→ arrow-operator is apocryphal.

• a→b→1 = a^b = a*... [a#b] = a→^.. ... [→#0 a#b 0_^]
• a→b→^...1 [→#c1] = a→^.. ... [→#c a#b]
• Car_ψ(a) = a→a→→1 = a→... [a#a] = Car_φ(a,...) [a#a]
• Car_ψ(i) =>> { 1, 4, 3^^7625597484987,
                 4→4→(4→4→(4→4→256→3)→3)→3, .. }

The 2nd rule counts chained arrows directly when c=1 and from this Car_ψ follows in the line below. Of the numbers Conway mentions in his book Car_ψ(4) = 4→4→4→4 is already physically inexpressible without resort to a function faster than super-powers.

§3.0.4. A row of operator subscripts

Comma separated coefficients can be extended naturally by the same rules for subscripted operators we saw above for operators ^d... right up to the end of a first row ^d,..,z...
But it's not obvious how to handle the initial cases of operator subscripts. The concept that a low level parameter can seed a very high one is called uploading and the Big numbers created by such rules are unprecedented.
The next functions of e-init and e-step choose for double upward substitution of b for c=1 and d=1.

• a^_1,1;b = a^_b;^...b [^_b;#b]
• a^_1,e1;b = a^_b,e;^...b [^_b,e;#b]

Continue to apply this kind of multiple substitution in the definition of subscripted arrow and star operations.
It should be clear by now that operant b, operator count c and following subscripts d,e,.. are similar iterator parameters, each iterating over a previous parameter (with the provision that b iterates over constant a and that a sequence of operators with mixed subscripts is not counted by arrows).

We'll suffix _c before a row of arrow coefficients to improve readability. You should substitute a^R;..b [^_R;#c] for a^c,R;b in this general formula for subscripted majority arrows, to get the original countable operator form.

• a^_1;b1 = a^_0;(a^_1;b) =>> a^_0;... [a#b1] = a... [a#b1 0_^]
• a^_1,...;b [1#k1] = a^_b,...;b [b#k]
• a^_1,...,n1,R;b [1#k] = a^_b,...,n,R;b [b#k]
• a^_c1,R;b1 = a^_c,R;(a^_c1,R;b) =>> a^_c,R;... [a#b1]

With uploading we substitute higher parameters for a value accumulated in a lower parameter – that is b in case of subscripted arrows and stars. Without this mechanism it's hard to see how ordinary unnested functions can move into the Conway level of super-chained arrows.
Uploading parameter values from the first row is definitely the way for us to conquer the next dimension.

Later, when we'll insert a new rule in bigI to accommodate mixed star subscripts, you'll see that the capacity lost by bigI's iterator collapse is redeployed to lift it a level higher in bigI's first row with waitor.
So if chained arrows issue a whole row of similar iterator y destructions, this dormant capacity in the keeping might just be the thing that allows us to gracefully lift a function of mixed arrows up to higher heavens.

§3.1.1. Mixed majority arrows?

Our formula for ^R; subscripted arrows did not cover mixed subscripts ^m;^n; [m≠n]
For a sequence of majority arrows with competing unequal subscripts the question is which one to evaluate next. We solve this issue by extending the fixity rules for arrow operations – namely right associative majority precedence – to include subscripts.
Majority precedence will apply externally between two subscripted operations, as well as internally in a single operation, where it chooses the reduction to apply first.

The right associative order of evaluation is only decisive, when subscripts are of equal size, in other cases size determines which operator is evaluated first. We do not use brackets in subscripts.
Subscripts live in a complicated multicultural environment, and the benefit from wielding such an expressive tool is increased notational resolution (more numbers can be expressed).
We won't cover all the combinations, but explain the most essential mixed arrows in a few examples. The smaller arrow in the operator reminds us of the postponed backslashed operation – it waits its turn.

After a certain reduction step the companion arrows ^n put on hold because of smaller size, will merge with the new, equally subscripted operators ^m; [m=n].

Because mixed operators governed by majority precedence do not add substantially to the size of numbers (compared to subscript parameter value), these will be treated as an insignificant variant.

§3.1.2. Mixed minority stars

Also in the definition of *R; subscripted star operations we extend their fixity rules – namely right associative minority precedence. These decide which reduction step to apply to a combination of mixed star subscripts.
Subscript inequality unfolds as a great tool in the construction of Big numbers. Given our observation that mixing of unequal arrow subscripts ^R is insignificant, we'll make a bigO comparison between the two subscript systems of minority stars and majority arrows.
The sign <~ means the left expression is algorithmically close(st!?) to the expression on the right, yet smaller.

Star subscripts are way ahead – when they put value d=2, arrows need a 2nd parameter e.
And when stars append the next iterator e, arrow subscripts come to the end of their first row.

The progression of mixed stars versus unmixed arrows gives us a tool to study similar systems at work on different levels. Minority stars are comparable to majority arrows, yet the stars as defined by the first row of parameters in bigI travel on a higher function level past the 4th parameter (compared to the arrows of bigE).
The general definition of subscripted minority star operations has a somewhat broader scope.

• aS*^..b1 [*#c1] = aS*^..(aS*^..b) [*#c *#c1]
               =>> aS*^.. ... [*#c a#b1]
  where S = *_Tj;;^.. .:. [*_Tj;;#k_j; *_Tj;;^..#m]
  where T_j; = t_jp,t_jpi,.. [t_jpi#n t_jq≠0] and T_j; > T_jd; [d>0]
• aS*_1,..,1R;b [1#k] = aS*_b,..,R;^...b [b#k *_b,..,R;#b]
  same S with T_j; > 1,..,1R
• aS*_1R;^...b [*_1R;#c1] = aS*_1R;^...*_R;^...b [*_1R;#c *_R;#b]
  same S with T_j; > 1R

The order of star subscripts *T; is quite intuitive, even if the conditional comparisons T > R are difficult to define exactly. In the reduction train of bigI to natural number this is usually not a problem – when we start from the evaluation of an expression a*R;..b [*#c] all subsequent mixed subscripts will satisfy these conditions.

§3.2.1. Minority pluses

The venerable plus operator snatched new meaning, when we established addictive counting with a left associative unary operator + and single subscripts a+c;... [+c;#b] in chapter 1.5.
These pluses are ruled by very simple concepts. As we already saw, in the 0th dimensional case + equals 1.

• a+_0; = a+ = a1 = a+1
• a+_c1; = a+_c;^... [+_c;#a]
• a+_c;^... [+_c;#b1] = (a+_c;)+_c;^... [+_c;#b]

In practice brackets are not necessary for the reduction of minority pluses, but they help us write out definitions concisely. For instance the last rule could be restated in two rules for +0; and +c1; without brackets.
Now try to fit a 4th coefficient d into this evaluation system, modelling it after parameter d of majority arrows.

• a+_++;; = a+_+1;; = a+_1,1; = a+_a1; = a+_a;^... [+_a;#a]
• a+_++;;^... [+_++;;#b1] = (a+_1,1;)+_1,1;^... [+_1,1;#b]
• a+_++;^...; [+_+;#c1] = a+_c1,1; = a+_c,1;^... [+_c,1;#a]
• a+_++^...;; [+#d1] = a+_1,d1; = a+_a1,d; = a+_a,d;^... [+_a,d;#a]

Expand this to a row of equally subscripted +R; operators, comparable to majority arrows.

• a+_1,..; [1#k1] = a+_a,..;^... [a#k +_a,..;#a]
• a+_1R; = a+_R;^... [+_R;#a]
• a+_1,..,1R; [1#k] = a+_a,..,R;^... [a#k +_a,..,R;#a]
• a+_R;^... [+_R;#b1] = (a+_R;)+_R;^... [+_R;#b]

§3.2.2. Mixability of pluses

The question arises whether we can successfully mix unequal subscripts into the general definition of these unary plus operators? Does the possibility of a+m+n [m≠n] work out naturally into a tremendously fast operator system, parallel to the way mixed subscripts for minority stars followed up on super-powers?

Because multiple pluses are left associative, as shown in the last rule the answer seems no. And indeed, if mixed pluses were ruled by minority precedence we could conclude the minority pluses system by simple recursion.

But when we agree to apply majority precedence (with the operator sign plux ×), a larger subscripted ×R; operator can extend the range from operant a to include all the smaller subscripted ×R'; operators in between.
Given an expression with mixed pluxes, the largest subscripted (leftmost) operator is evaluated first and all the mathematical terms on its left become subject to repetition (by character duplication).

Because a plux has a single left operant there's a nasty problem – the iterator value to count these repetitions has to be derived from the repeated sequence itself. To achieve this the left sequence has to be reduced to natural number first. And then the original unreduced left characters are to be iterated over.
This cannot happen in place, but requires two separate programme states. Enumeration of states of computation is a complication issue we will not dive into in this article.
Our focus is on general recursion and not computability, though we'll miss out on some truly Big numbers.

With unary operators mixed sequences such as in the general formula of mixed minority stars, if possible, will have to occupy some secondary space for evaluation. For instance, a plux at the right end could still employ the empty character space on its right to perform a calculation, but this extension of operator sequences to derive an iterator value essentially uses temporary (nested) right operants.
These alternatives of countable programme states and virtual extra operants are not truly what operators are about. Such constructions are better set in the framework of functions and their operatorial extensions in part two.

We will forget about majority pluxes and happily raise bigA on the foundation of minority pluses, which look so simple but are to our surprise more powerful than the arrowheads ^.. of operatorial bigE. This is proved in chapter 4.2.

§3.3.1. Repainting up-arrows

The definition of Conway's chained arrows is apt to draw its own bow → skip the basic trio a→b→c = a^...b [*#c] and derive super-powers directly from its axioms for the first row. That is, provided the duo is defined separately as exponentiation a→b = a^b, which slows the row expansion down by a parameter position, compared to a more rigorous application of the scheme of chained arrows.

We will define a right arrow function using the sign → as a parameter separator. On the operator axis a new algorithm for what we still call up-arrows ↑ (though not Knuth's, but painted by Novaloka) forms the basis.
Our notation applies the convention of majority precedence for arrow operators, leaving out brackets when possible.
Let's walk through the different forms of up-arrows, following the trail of an expanding row of parameters to the right.

• An operator ↑.. [#z] = a without operants to operate upon is strange, but natural z = 1.. [#a]
• The initial up-arrows a;0↑0;.. are unary a↑.. [↑#z] with z counting their series.
• Then come the still unsubscripted yet doubly iterable binary up-arrows a↑..y [↑#z]
• Continue with subscripted up-arrows a↑R;..y [↑_R;#z] which are unmixable, so you can either write for example a↑x;↑x;↑x;y or a↑x;↑↑y or a↑↑↑x;y as [↑_x;#3] is what's intended.

Within a series of up-arrows different subscripts will not mix – describe this property in a logical statement.

We've painted the new _zubscripts magenta (not red), to indicate that they shift to the right – with every final parameter z as an operator counter (instead of the fixed red c) and penultimate parameter y as the main iterator (instead of a fixed b).
For instance the operation a↑b,x;..y [↑_b,x;#z] equals the expression a→b→x→y→z.
This isn't just cosmetic – we'll position those parameters that most increase function speed (create the Biggest numbers) to the right of function arrays. In the chained arrows algorithm the double iterator z functions as operator counter and has the greatest impact on the result, since there is no uploading of accumulated iteration values.

§3.3.2. Redrawing right arrows

In this chapter we define a right arrow function with navy coloured separators → to distinguish it from chained arrows. Right arrows ai→... [ai#n] are roughly similar to chained arrows, but have three major differences.

• Of value importance – the a↑R;.. operator counter z is counted down (virtually) to 0 (and dropped) instead of dropping 1, in support of our general notion of operatorial functions.
• Of value importance – when penultimate iterator y counts down to 0 and collapses, it is revived by the prestine value of x. Only one parameter drops off, whereas chained arrows drops both last positions.
• Of parametric importance – the main axiom of the R→y→z scheme applies directly to the first two parameters a→z past [a≠1 z≠1] the initial cases.

Because a→b→c = a^..b [^#c] = a^0;..b [^0;#c] = a→0→b→c seems to make sense, in principle any parameter value zero in between could simply collapse its position. Plausibly even those at the start.

• X→0 = X
• X→0→Z = X→Z
• 0→Z = Z

Helped by our collapsing insight, only two axioms – the initial and the main axiom – suffice to define the row function of right arrows, together with its zubscripted up-arrow operators.
If however stuborn, we cannot accept axioms with zero values 0→ up front as item or in between as iterator, then we must adapt our rules that count down from 1 to express the same state of affairs. We list them below.

• a→1 = a↑ = a1
• 1→b1 = (0→b1)→b = b1→b
       = 1↑^.. [↑#b1] = b1↑^.. [↑#b] ~> 2*..b3 [*#b--]
• a1→b1 = (a→b1)→b
        = a1↑^.. [↑#b1] = (a↑^..)↑^.. [↑#b1 ↑#b] ~> 2*..a3 [*#b-]
• R→1→z1 = R→(R→0→z1)→z = R→(R→z1)→z
       [R:a]= a↑^..1 [↑#z1] = a↑^..(a↑^..) [↑#z ↑#z1]
     [R:a→x]= a↑_x;^..1 [↑_x;#z1] = a↑_x;^..(a↑^..x) [↑_x;#z ↑#z1]
   [R:a→Q→x]= a↑_Q,x;^..1 [↑_Q,x;#z1] = a↑_Q,x;^..(a↑_Q;^..x) [↑_Q,x;#z ↑_Q;#z1]
• R→y1→1 = R→(R→y→1)
       =>> R→(..R→1→1.) [#y#] = R→(..R→1.) [#y1#]
       [R:a]= a↑y1 = a↑^.. [↑#z z:a↑y]
     [R:a→x]= a↑_x;y1 = a↑^..x [↑#z z:a↑x;y]
   [R:a→Q→x]= a↑_Q,x;y1 = a↑_Q;^..x [↑_Q;#z z:a↑Q,x;y]
• R→y1→z1 = R→(R→y→z1)→z
        =>> R→(..R→z1.)→z [#y1#]
     [R:a]= a↑^..y1 [↑#z1] = a↑^..a↑^..y [↑#z ↑#z1]
   [R:a→Q]= a↑_Q;^..y1 [↑_Q;#z1] = a↑_Q;^..a↑_Q;^..y [↑_Q;#z ↑_Q;#z1]

The translation from Novaloka's up-arrows to right arrows doesn't look so smooth, but it's workable. The numbers created by our right arrows → are a single parameter Bigger than Conway's chained arrows → which is not terribly significant on a grand scale, where parameter rows R can be stretched to arbitrary length.
If you'd like to see how the above estimate a→b2 ~ 2*..a2 [*#b] of two parameter super-powers was reached, click here!

• a→2 = (a-→2)→1 = (a-→2)1 =>> (0→2)a = a2
• a→3 = (a-→3)→2 = (a-→3)2 =>> (0→3)(a*2) = (2*a2)-
• a→4 = (a-→4)→3 ~> (a-→4)*2 =>> (0→4)*2^a ~ 2^a2
• a→5 = (a-→5)→4 ~> 2^(a-→5) =>> 2^^a\^(0→5) ~> 2^^a2
• a→b [a>1] = (a-→b)→b- ~> 2^..(a-→b) [^#b-4]
          =>> 2*..a\*..(0→b) [*#b-2 *#b-3] ~> 2*..a2 [*#b--]

If we fill in the extremum 1→b1 in the main rule, our approximation of the two parameter case turns out rather crude.

§3.3.3. Mixing down arrows

under 2010 construction

Initially arrow expressions are without multiple subscripted operators – the opportunity for mixing didn't occur yet – this is where up-arrows and down-arrows do not differ in function and result.

• a←y←z = a↓^..y [↓#z] = a↑^..y [↑#z] = a→y→z
• a←x←1←1 = a↓_x;1 = a←x←(a←x←0←1) = a↓^..x [↓#z z:a↓x]
          = a↑^..x [↑#z] = a→x→(a→x→1) = a→x→1→1 = a↑_x;1
• a←x←y1←1 = a↓_x;y1 = a←x←(a←x←y←1) = a↓^..x [↓#z z:a↓x;y]
           = a↑^..x [↑#z] = a→x→z = a↑_x;y1 = a→x→y1→1

Obviously the final parameter z stays unmixed, because it expresses the number of possible mixings. Less obviously the penultimate parameter y is reserved to contain a waitor subexpression and shouldn't be subscripted or mixed.
Follow the translation rules for revolving arrows around the clock.

• a←R←x←0←z1 = a↓_R,x;^..0 [↓_R,x;#z1] = a↓_R,x;^..↓_R;x [↓_R,x;#z]
• a←1←1←2 = a↓_1;↓_1;1 = a←1←(a←1←0←2)←1 = a↓_1;a↓_1;↓1
          = a↑_1;a↑↑_1;1 = a→1→(a→1→1→2)→1 = a→1→2→2 = a↑↑_1;2
• a←x←1←2 = a↓_x;↓_x;1 = a←x←(a←x←0←2)←1 = a↓_x;a↓_x;↓x
          = a↑_x;a↑↑_x;x = a→x→(a→x→x→2)→1 = a→x→x1→2 = a↑↑_x;x1
• a←x←2←2 = a↓_x;↓_x;2 = a←x←(a←x←1←2)←1 = a↓_x;a↓_x;↓_x;1
          = a→x→(a→x→x1→2)→1 = a→x→x2→2 = a↑↑_x;x2
• a←x←y1←2 = a↓_x;↓_x;y1 = a←x←(a←x←y←2)←1 = a↓_x;a↓_x;↓_x;y
           = a→x→(a→x→xy→2)→1 = a→x→xy1→2 = a↑↑_x;xy1
• a←x←1←3 = a↓_x;↓_x;↓_x;1 = a←x←(a←x←0←3)←2 = a↓_x;↓_x;a↓_x;↓_x;↓x
          = a→x→(a→x→xy→3)→1 = a→x→xy1→3 = a↑↑_x;xy1
• a←x←1←z1 = a←x←(a←x←0←z1)←z
           = a↓_x;^..1 [↓_x;#z1] = a↓_x;^..a↓_x;^..↓x [↓_x;#z ↓_x;#z]
           = a↑_x;a↑↑_x;x = a→x→(a→x→x→z1)→z = a→x→x1→z1 = a↑↑_x;x1
• a←1←y1←z1 = a↓_1;^..y1 [↓#z1]
            = a↓_1;^..↓^..y1 [↓_1;#z ↓#v] where v = a↓_1;^..y [↓_1;#z1]
• a←x1←y1←z1 = a↓_x1;^..y1 [↓#z1]
             = a↓_x1;^..↓_x;^..y1 [↓_x1;#z ↓_x;#v] where v = a↓_x1;^..y [↓_x1;#z1]
• a←R←y1←z1 = a↓_R;^..y1 [↓#z1] = a↓_R;^..↓_R-;^..y1 [↓_R;#z ↓_R-;#y1]

More arrow quarters round the clock.

§3.4.1. Revolving the axis

There's a beautiful story recalled by Richard D. Gill, how John H. Conway derived a power tower of omegas ω on a small blackboard, that he rotated 90° clockwise to create a much larger infinite expression involving epsilons εεε..

Using ω→2→3 = ω^^ω = ε0 to express ε0→2→4 is not so impressive as it seems, considering the chained row of omegas ω→.. [ω#ω] that must have been on Conway's mind when he invented his chained arrows.
We don't want to spoil Gill's story here. It gains interest when we find a way to turn clockwise the very arrows Knuth and Conway started with! This involves a revolution of the arrow's axis. Of course the first turn is Conway's…

§3.4.2. The next revolution

An operatorial O is a container O(T) with an array of parameters O(a,..,z), where every next term is an iteration counter, modelled after and expanding on previous terms, and based on an initial case O(a,1).
The term basic refers to the primitive recursive function class or the super-power level of construction. A related subclass is Kalmár's elementary, which covers all functions defined by iterations up to multiplication.

To evaluate an expression of an operatorial completely, it is reduced to the smallest possible number of operations on units. Without other numeric units than 1 the final reduction of an operatorial must always deliver a natural number. This is what's meant with reducibility, and every new rule should preserve it!

Creating operatorials for Big numbers is more of an art than a science. Our bigE should capture all recursive functions under the hood (if yours accelerates faster we'll catch up later), by extrapolating the principles of natural operators to higher parameter dimensions and beyond.
We'd like simplicity to be our guide, but this is alas not trivial. Contrary to popular belief it is not the higher which rules the lower from above. Operatorial higher constructs facilitate the lowest to iterate over all other constructs below the higher. In a fast algorithm the highest intervention – characterized by z countdown – will happen very very rarely.

The post-reduction and post-countdown destructors lay the foundation for all operatorials. Both rules are marked here in the generic context for bigE.
The post-reduction axiom maps a single item (such as a natural number) to itself. Post-reduction in the context of bigI can also be incorporated by its addition rule.
The generic post-countdown axiom is most fundamental for bigO as it puts a lower limit to all iterations, but it can perhaps be overruled in a special case of z=0 such as via the substitution definition of multiplication in bigE.

• O(a) = a
  so  O() =   = 0  if a = 1.. [1#a]
• O(X,) = O(X)
  so  O(X,0) = O(X)

§4.0.2. Basic bigE

Traditionally multiplication is defined by repeated addition – recursively in two steps. Notice that the initial step of unity is already contained via the two generic axioms E(a,0) = a, so the zero-arrow definition of bigE is not a complete fit, because it does not cover multiplication by zero, which is unreachable as the iterator drops at b=1.

• E(a,1) = E(a) = a
• E(a,b1) = E(a E(a,b)) [b>0]
        =>> E(a... E(a,1)) [a#b] = E(a...) [a#b1]
          = a+... [a#b1] = a(b+1) [0_^] = a*b1 [0_*]

You might like to leave multiplication untouched, there's something to say for that – just drop the single separator and collect the result E(a,b) = ab = a*b
For bigE we are tempted to choose the substitution definition of multiplication, where the value b=0 is allowed to overrule the generic post-countdown axiom for once. Unusual here is that a functions as an iterator over b, while bigE's version of the lonely separator completely replaces all units 1 in a by the value b

• E(a,b) = E(1...) [1#a 1:b]
         = b+... [b#a] = ba [0_^] = b*a

Now how is this suddenly possible? As the last single separator is dropped, the algorithm of bigE should select the highest remaining separators to grab its parameters from. At the lowest level dwell the empty separators which add the unit parameters that compose numbers – so that finger counts 1 become available now… Contrived?

Naturally an iterator countdown is a zero-level process too – dropping what seems to be a 0 number of separators , in between z1 => z. Consider this a context where zero space 0, = 0* =  
We can take the hair-splitting yolk to its amniotic extreme and define addition in bigE by assuming separators of size 0 and then iterating over the two virtually separated values of a and b. The result is the same as without the empty separator, but that's what you always have with addition.

• E(a,^...b1) [,#0] = E(a1,^...b) [,#0]
                 =>> E(a1...,^...1) [1#b ,#0]
                   = E(a1...) [1#b1]
                   = E(ab1) = a+b+1 = ab1 [0_*]

Basic recursive definition of bigE with 3 parameters – first an example (exponentiation), then two (temporary) axioms.

• E(a,b1,1) = E(a,E(a,b,1)) =>> E(a,..a.) [#b#]
            = a... [a#b1 0_^] = a^(b+1) = a**b1
• E(a,1,c1) = E(a,1,c) =>> E(a,1) = a
• E(a,b1,c1) = E(a,E(a,b,c1),c) =>> E(a,..a.,c) [#b#]
             = a^^.. ... [^#c a#b1] = a^^...(b+1) [^#c1]

§4.0.3. Basic bigI

Follows the basic abc of operatorial function bigI, called the big Iteration. Compared to the big Expansion of bigE, an advantage of bigI could be that it incorporates addition ab with its initial pair of parameters.
The definition list of bigI covers super-powers with the 3d parameter c counting the number of stars *.. of the corresponding super-power operation, multiplication represented by a single star.
Here too, multiplication by zero cannot be reached by reduction of any expression of bigI.

• I(a,1) = I(a1) = a1
• I(a,b1) = I(I(a,1),b) =>> I(ab,1) = ab1
• I(a,1,1) = I(a) = a
• I(a,b1,1) = I(a,I(a,b,1)) =>> a... [a#b1 0_*] = a*b1
• I(a,1,c1) = I(a,1,c) [c>0] =>> I(a,1,1) = a
• I(a,b1,2) = I(a,I(a,b,2),1) =>> a*... [a#b1] = a**b1
• I(a,b1,c1) = I(a,I(a,b,c1),c) =>> a*^.. ... [*#c a#b1]

We'll continue modelling the operatorial bigI after mixed star operators, expanding the above lists to a row of parameters in chapter 5.3. As it turns out bigI is the big brother of bigE, whose first row is the next construction, building upon the basic parameters defined in this chapter.

§4.0.4. Axioms of addition

The recursive definition of addition in bigI is a threefold loop – starting off as an induction step on two parameters, it drops second parameters b=1 by succession, which in turn destructs the function post-reduction.
The case of b=0 must then be resolved post-countdown (not by inverse construction) to completely define addition as we like it.

But addition I(a,b) is also the natural choice for an initial axiom of bigI. It is then defined as a rewrite rule — to drop the lonely separator comma , together with the function I brackets.
As was demonstrated as early as chapter 1 the operator of addition is empty and redundant. Succession is surpassed by addition of 1, the next rule in bigI's definition list. And the impractical rule of post-reduction of one unreduced parameter a is derivable by inversed application of the post-countdown axiom.

Therefore an addition which drops the lonely separator can function perfectly as a stand-alone axiom to deal with the final reduction of expressions in a super-power operatorial.

Compare the axiom of addition by zero separators in bigE. We feel that countable separators are an indispensable property of operatorials, and that bigE applies this more rigorously than bigI.
However, with the introduction of waitors to accommodate mixed minority stars in parameters on the front row, the single value c=0 wasted on addition becomes the hallmark of bigI's row expansion.

§4.0.5. Definition lists and function hierarchy

A function definition is an equation existing of a new rule A=B, defining a reduction from A to B. With often appended a conclusion B=..Z derived by iteration =>> of the rule and/or from the preceding definition context.
This context has 3 types of scope – from generic rules, from earlier lists, or from earlier definitions in the same list.

Within the same definition list provisional and fundamental rules prescribe a certain order of application. For example, the rule I(a,1,c1) is listed before super-powers I(a,b1,c1), prescribing that in case b=0 the former rule takes precedence, even if the latter rule is declared without specifying that b>0.
When a rule is not fundamental (an axiom), it will be overruled by a more general definition in a following definition list. Our job is to abstract new rules, create Bigger numbers and keep the context expanding forever…

A definition list should cover an (intuitive notion of an) operatorial hierarchy – in the case of bigI the *... [*#n] operators. The definition lists in this chapter present the basic context of super-powers, so that each basic operatorial covers all subclasses of the primitive recursive Grzegorczyk hierarchy.

Because operatorials build natural numbers 1.. they shun the number 0 from their definitions. Any awkward expression with an inner parameter value of 0 should be resolved by inverse recursion, which iterates backwards from an initial value 1, as is done here for the familiar 0 values of super-power iterators.

We try out inverse recursion to determine how negative operators work – many solutions are the same and extract a successor function on b. However, there are second solutions, can you see?

An aesthetic solution, but Peano will have to wait for negative eternity for the ambiguity about true negative functions to go away – it is only the probability of his successor function that rises…
A few hints for future research:

Considering the fundamental role of the successor function we may well be hallucinating here.
It's alright to define I(a,b,-*n) [n>0] = b1 as an axiom. There's an overwhelming amount of evidence to show that the operation that precedes addition need not be difficult – compare Gr or Fa- above and the translation of Rózsa Péter's recursion to bigI format below. Because the Big Lebowski calls this zeration and thinks highly of it, we've restated its law in double Dutch for all Dudes.
The inverse separator reminds us of the relations between inverse points, counted by Newton's negative binomial.

The formula for primary negative iterators b by application of inverse recursion, is given as an exercise.

§4.2.1. Basic bigA and affiliates

Translate the rules for unary minority pluses to the basic parameters of a new operatorial function bigA.

• A(a,1) = a+ = a1
• A(a,b1) = a+^... [+#b1] = ab1
• A(a,1,c1) = a+_c1; = a+_c;^... [+_c;#a] = A(a,a,c)
• A(a,2,c1) = A(A(a,a,c),A(a,a,c),c)
• A(a,b1,c) = a+_c;^... [+_c;#b1] = (a+_c;)+_c;^... [+_c;#b]
            = A(A(a,1,c),b,c)

We've described the case Rmin(0;a,b,c) of unbracketed minority stars in section 2.4.3. We'll derive a slightly faster function Fb = a×...b [×#c] by unbracketing the function family Fac from section 2.0.3.
It will then become clear that the binary function Fb() and the unary operatorial A() are the same, at least in the basic three parameters.

First restate the rules for function family Fac(a,b) to Fa(a,b,c) in operatorial format.

• Fa(a,b1) = Fa(a,b)1 =>> Fa(a)b1 = ab1
• Fa(a,1,c1) = Fa(a,a,c)
• Fa(a,b1,c1) = a×^...b1 [×#c1] = a×^...(a×^...b) [×#c ×#c1]
              = Fa(a,Fa(a,b,c1),c)

Assume the operator × of Fa and Fb is ruled by right minority precedence.
Unbracket Fa by removing brackets ( -> (0 in the last rule of the above definition.

• Fb(a,b) = ab
• Fb(a,1,c1) = Fb(a,a,c)
• Fb(a,b1,c1) = a×^...b1 [×#c1] = (a×^...a)×^...b [×#c ×#c1]
              = Fb(Fb(a,a,c),b,c1)

Because the two step reduction A(a,b1,c1) = A(A(a,a,c),b,c1) matches the main rule of Fb and the previous two rules are the same, operatorial A equals function Fb in the super-power context.
From this we conclude that for 3 parameters, bigA increases faster than bigI on two points – because Fa starts squaring sooner than bigI at b=1 and because its unbracketing to function Fb mostly produces notably bigger numbers, as it feeds the substituent expression to the larger operator (this was explained in section 2.4.3).

But how fast is bigA approximately compared to bigE?
The dagger sign † is used to cut calculations short.

• A(a,1,1) = A(a,a) = aa = a*2
  A(a,b,1) =>> A(.a.,1,1).. [#b#] = a*2^b
• A(a,1,2) = A(a,a,1) = a*2^a
  A(a,2,2) = A(A(a,1,2),1,2) = a*2^(a*(2^a+1)) ~> 2^2^a †
  A(a,3,2) = A(A(a,1,2),2,2) ~> 2^2^(a*2^a) ~> 2^2^2^a †
  A(a,b,2) =>> A(.a.,1,2).. [#b#] ~> 2^^b\^a †
• A(a,1,3) = A(a,a,2) ~> 2^^a†
  A(a,b,3) =>> A(.a.,1,3).. [#b#] ~> 2^^^b\^^a†
• A(a,1,c) = A(a,a,c-) ~> 2^^..a† [^#c-]
  A(a,b,c) =>> A(.a.,1,c).. [#b#] ~> 2^^..b\^^..a† [^#c ^#c-]

Unlike unbracketed stars versus arrowheads, when c>1 early riser bigA is always slashly ahead of bigE.
This is because: a^^b < 2^^b\^a in which the final exponent a < 2^a is dominant.

§4.2.2. Half-speed super-powers

Getting your hands dirty and making mistakes is recursionist practice.
In chapter 2.1 we asked if there exists a continuum of algorithms in the gap between super-power counts of c of which we've so far only met the integer values. This is a problem Stephen Wolfram posed recently.
Natural candidates for the position E(a,b,½) halfway between multiplication a*b and powers a^b for example, are the binary exponential function a*2^b or the factorial a! perhaps.
Today in our algorithmic laboratory we stumbled across the following approximate evaluations for tryB.

• B(a,b,1) = B(aa,b-,1) =>> (.a.*2).. [#b#] = a*2^b
• B(a,2,2) = B(B(a,a,1),a,1) = a*2^(a*2)
  B(a,b,2) =>> B(.a.,a,1).. [#b#] = a*2^(a*b)
• B(a,2,3) =>> B(B(a,a,2),a,2) ~> 2^(a^2*2^a^2)
  B(a,b,3) =>> B(.a.,a,2).. [#b#] ~> 2^^b\^(a^2)
• B(a,2,4) =>> B(B(a,a,3),a,3) ~> 2^^a\^(2^^a\^(a^2))
  B(a,b,4) =>> B(.a.,a,3).. [#b#] ~> 2^^(a*b)
• B(a,b,5) =>> B(.a.,a,4).. [#b#] ~> 2^^^b\^^(a^2)

This function tryB expands pairwise and traverses the super-power hierarchy at half the speed of bigA!
But how does one construct the algorithm? Should we supply an extra coefficient to store left parameter a temporarily, or can we retrieve the appropriate variable a from within the depth of all nests?
The first option would require us to remember these a somehow as waiting on a particular c too.
We choose a nested notation, which keeps expressions substituting for the first parameter unresolved, until the outer iteration counts down to value b=1. Nested subexpressions put on hold like this are called waitors.

We use the waitor mechanism to reduce super-power function speed to a fraction of one half. But tryB is not dependent on its special rules for waitors w. The whole mechanism can be taken care of by the nested recursion in the conclusion of tryB's main axiom (in the last line).
To indicate that tryB's special waitor rules can be represented alternatively as nested recursion these are marked as transient (with left a small circle). But when you'd insist on having a construction in the simplest of steps, the waitor rules should be considered fundamental.

Define our algorithm for tryB. The substituent expressions w are waitors B(v,1,c) nested to arbitrary depth. Variables a and v can be either natural numbers n or waitors, where v is selected for reduction by unnesting.

• B(1..) [1#n] = n
• B(a,1) = a1
• B(a,b) = B(B(a,1),b-) =>> B(.a.,1).. [#b#] = ab
• B(a,1,1) = B(a,a) = a*2
• B(a,b,1) = B(B(a,1,1),b-,1)
         =>> B(B(a,b-,1),1,1) = B(a,b-,1)*2 =>> a*2^b
• B(v,1,c) == B(v,B(v),c-)
• B(x,B(w),c) [w:B(v,1,cd) c>0] = B(x,B(v),c) [d<2]
                              or  B(x,w,c) [d≥2]
• B(a,b,c) = (w,b-,c) [w:B(a,1,c)] =>> B(.a.,1,c) [#b#]
           = B(B(a,b-,c),1,c) == B(B(a,b-,c),a,c-)
           =>> B(B(B(a,b-,c),a-,c-),B(a,b-,c),c--)
         =>> B(.w.,a,c-).. [#b-#] = B(.a.,a,c-).. [#b#]

It is sometimes difficult to realize we are still dealing with numbers here. For two examples of step by step evaluation of numerical expressions in tryB, click here!

A more precise mathematician may prove tryB's set of rules with waitors cannot be derived by primitive recursion, as the existence of the Grzegorczyk hierarchy suggests (else his concept of hierarchic function classes is in reality less strict). To us the above steps in the definition of tryB look quite primitive, but to prove that they are (as we conjecture) is not crucial for our discussion.
The striking feature of tryB is that it distinguishes between even and odd values of c in order to subdivide Grzegorczyk's enumeration of super-power functions in two.

Follows our proof that tryB increases at half the speed of super-powers. We take all reduction steps from the outside in – with no resort to the unofficial 6th rule for waitors – but with many short cuts. Expressions of tryB are approximately translated to arrows by means of backslashes \.
To show the whole construction of our proof by example, click here.

• B(v,b,1) = B(B(v,1,1),b-,1) =>> B(.v.,1,1).. [#b#]
           = B(v,b-,1)*2 =>> B(v,1,1)*2^b- = v*2^b
• B(v,b,c) = B(B(v,1,c),b-,c) =>> B(.v.,1,c).. [#b#]
           = B(B(v,b-,c),1,c)) = B(B(v,b-,c),B(v),c-)
• B(a,1,2) = B(a,a,1) = a*2^a
• B(a,b,2) == B(B(a,b-,2),a,1) = B(a,b-,2)*2^a
          =>> B(a,1,2)*(2^a)^b- = a*2^(a*b)
• B(a,1,3) = B(a,a,2) = a*2^a^2
• B(a,b,3) = B(w,1,3) [w:B(a,b-,3)] == B(w,a,2)
           = B(B(w,a-,2),1,2) == B(B(w,a-,2),w,1)
           = B(w,a-,2)*2^w =>> w*2^(w*a)
           ~ 2^(a*B(a,b-,3)) ~ 2^..B(a,1,3) [2^#b-]
         ~ 2^^b-\^(a^2*2^a^2) ~ 2^^b\^a^2
• B(a,1,4) = B(a,a,3) ~ 2^^a\^a^2
• B(a,b,4) == B(w₄,a,3) [w₄:B(a,b-,4)]
           == B(w₃,w₄,2) [w₃:B(w4,a-,3)]
            = w₃*2^(w₃*w₄) ~ 2^B(w₄,a-,3)
          =>> 2^^a-\^B(w₄,1,3) == 2^^a-\^B(w₄,w₄,2)
            = 2^^a-\^w₄*2^w₄^2 ~ 2^^a\^B(a,b-,4)^2
          =>> 2^^a\^(..B(a,1,4).)^2 [#b-#]
            ~ 2^^(a*b-)\^(2^^a\^a^2) ~ 2^^(a*b+2)
• B(a,1,c1) = B(a,a,c)
      [c%2=0] ~ 2^^..(a^2+2) [^#c/2].
      [c%2=1] ~ 2^^..a\^^..a^2 [^#c1/2 ^#c-/2].
• B(a,2,c1) = B(w₀,a,c) [w₀:B(a,1,c1)]
            = B(w₁,w₀,c-) [w₁:B(w0,a-,c)]
      [c%2=1] ~ 2^^..(w₁*w₀) ~ 2^^..w₁ [^#c-/2]
            =>> 2^^..a-\^^..B(w₀,1,c) [^#c1/2 ^#c-/2]
              ~ 2^^..a-\^^..(2^^..w₀) [^#c1/2 ^#c-/2 ^#c-/2]
              ~ 2^^..a\^^..w₀ [^#c1/2 ^#c-/2]
              ~ 2^^..(a*2)\^^..a [^#c1/2 ^#c-/2].
      [c%2=0] ~ 2^^..w₀\^^..w₁ [^#c/2 ^#c--/2]
            =>> 2^^..w₀\^^..(..B(w₀,1,c).) [^#c/2 ^#c--/2 #a-#]
              ~ 2^^..(w₀*a-)\^^..2^^..w₀ [^#c/2 ^#c--/2 ^#c--/2]
              ~ 2^^..(w₀*a) [^#c/2] ~ 2^^..w₀ [^#c/2]
              ~ 2^^..2^^..(a^2) [^#c/2 ^#c/2].
• B(a,b,c1) = B(w,a,c) [w:B(a,b-,c1)]
            = B(B(w,a-,c),w,c-)
      [c%2=1] ~ 2^^..a-\^^..B(w,1,c) [^#c1/2 ^#c-/2]
              ~ 2^^..a\^^..B(a,b-,c1) [^#c1/2 ^#c-/2]
            =>> 2^^..a\^^..(..B(a,1,c1).) [^#c1/2 ^#c-/2 #b-#]
              ~ 2^^..(a*b-)\^^..2^^..a\^^..a^2
                    [^#c1/2 ^#c-/2 ^#c-/2 ^#c---/2]
              ~ 2^^..(a*b+2) [^#c1/2].
      [c%2=0] ~ 2^^..w\^^..(..B(w,1,c).) [^#c/2 ^#c--/2 #a-#]
              ~ 2^^..B(a,b-,c1) [^#c/2]
            =>> 2^^..(..B(a,1,c1).) [^#c/2 #b-#]
              ~ 2^^..b-\^^..2^^..(a^2+2) [^#c2/2 ^#c/2 ^#c/2]
              ~ 2^^..b\^^..(a^2) [^#c2/2 ^#c/2].

The numbers expressed by bigA and tryB always lie near super-power multiples of two. Factor a is dwarfed by the repetition of items 2 produced by the double iteration over b and c as the numbers get bigger. Therefore tryA and tryB are said to express a binary-exponential order.
The difference is that tryB moves at half the speed of tryA, so its resolution (the number range covered by 3 parameters in tryB) is twice as good as super-powers.

under 2010 construction

§4.3.1. Extending the factorial

The factorial operation a! = 1*2*3*..*a hasn't received a proper update since John Wallis published Arithmetica Infinitorum (1656) and his Algebra (1685).
We propose a new definition for an enumerable sign !X as the operator of the upcoming operatorial bigU. Because the general function is so fast, we've nicknamed it the fastorial.
You can forget about the slow superfactorials Sloan & Plouffe and Pickover defined in 1995, those are both exponential hybrids. For Big number lovers the factorial nature of the new super-factorial a!b operation – where b sits on the fastorial front row – is paramount!

Our super-factorial operators !b are always subscripted with a coefficient, starting with !1 (the good old a! factorial) defined by i*... [i#a] using an incrementor i.
Two factorials in a row a!1!1 = (a!1)!1 will be evaluated from left to right. Likewise a series of mixable (not necessarily the same) super-factorial operators.

All fastorials !X are left associative. You can compare this to the coefficient used in the short cut formula for majority arrows, for which mixing unequally subscripted operators was deemed insignificant.
The super-factorial !b is a unary operator. Unary operations enjoy a higher precedence than binary operations, so for example m*n!1 = n*(n!1) evaluates the factorial with priority.
The b in a!b functions as a binary operant on a, but because we allow the subscript to contain more than a row of iterators, we've practically done away with the notion of n-ary operators. The operatorial function bigU comes instead.

Keep in mind that a number variable a is a series 1... [1#a] of characters one. Then a single 1 counted down to 0 will be a series of zero ones, nothing but an empty space.
Applying the generic operatorial axioms to bigU below, the unsubscripted !0 = ! would equal 0 if it was allowed.
The third general axiom will be applied to counting down U(1,b) and is unique for bigU.

• U(a) = a (bracket drop at a number)
• U(A,) = U(A) (right comma drop at z=0)
    so  U(a,0) = a!₀ = a
• U(,Z) = U(Z) (left comma drop at a=0)
    so  U(0,b) = 0!_b = b

Follows the definition of the basic two super-factorial parameters of bigU.
The evaluation of numbers with zero space [0_*] in between follows the star convention, so in a- = a-1 and a1!1 = (a+1)! an immediate form of addition takes place (variables and units combine with precedence).
Work out a few cases with the new super-factorial !2 click here!

• U(1,1) = U(U(0,1),0) = U(U(1)) = 1
• U(a,1) = U(1...) [1#a 1:U(a-,1)] = U(U(a-,1)*a)
       =>> 1*i... [*i#a] = a!₁ = a! (factorial)

• U(2,2) = U(U(2,1)*2,1) = 4!
  U(3,2) = U(24*3,1) = 72! ~ 6.12345*10^103
  U(4,2) ~ U(6E103*4,1) ~ 2E104!
  U(5,2) ~ U(2E104!*5,1) ~ 2E104!!
• U(a,2) = U(v*a,1) [v:U(a-,2)] =>> (.2.*i)!₁.. [#a#]
         = a!₂ ~ 2E104!^.. [!#a-3 a>3]
• U(2,3) = U(3!₂*2,2) ~ 1E104!₂ ~ 2E104!^.. [!#1E104]
  U(3,3) = 3!₃ ~ 1E104!₂!₂
  U(a1,3) ~ u!₂^.. [!₂#a] & u = ((4!₁*3)!₁*2) ~ 10^104 <~ 5!!
• U(2,4) = U(4!₃*2,3) ~ 4!₃!₃ ~ u!₂!₂!₂!₃
  U(a1,4) ~ 4!₃^.. [!₃#a1] ~ u!₂!₂!₂!₃^.. [!₃#a]
• U(2,5) ~ 5!₄!₄ ~ 5!₁!₁!₂!₂!₂!₃!₃!₃!₃!₄
  U(a1,5) ~ 5!₁^..!₂^..!₃^..!₄^.. [!₁#2 !₂#3 !₃#4 !₄#a]

• U(1,b1) = U(b1,b) = b1!_b
• U(2,b1) = U(U(b1,b)*2,b) ~ b1!_b!_b [b≥2]
• U(a1,b1) = U(v*a1,b) [v:U(a,b1)]
         =>> (.b1.*i)!_b.. [#a1#] = a1!_b1 (super-factorial)
                                 ~ b1!_b;^.. [!_b;#a1]
           ~ 5!_i^...:.!_b;^.. [!_i#i1 !_i^..#b !_b;#a]

So you create a maximal predecessor subexpression v by counting down the first entry a in an array of U. Then retake the original expression U and count down the leftmost available iterator (value not 1 unless it's the final entry) right of a (here that's b which can be dropped) to form outer expression. And substitute all units in the parameter(s) left of the outer iterator (here each 1 of a) for inner expressions v.

§4.3.2. Speed of the super-factorial

The principle of bigU is to consequently replace every increasable construct by the maximal predecessor v. Just like a length is increased when we substitute its units of length, a number variable is seen not as a whole number, but as a series of units 1 (separated as it were by 0 commas), which isn't increased directly but through its units. This depends on the function of the single separator , for when the outer iterator lies to the right of a double comma ,, the number of parameters is increased too.

In general only the rightmost increasable construct is significant, which when substituted for v delivers a function increasing approximately just as fast as bigU. Simply replacing the whole variable a as in Rózsa Péter's recursion has comparable strength. (though she misses the factorial nature on our planet)~:
However, the problem lies in recognizing constructs, we only (try to think like a Vegan:~) expand units 1 and , in expressions of bigU.

Two reasons why bigU's basic pair of super-factorial parameters is the perfect Hînayâna motorcycle.
The original ideas are – substitution of the smallest dimensions (the units 1) and multiple alternating recursions.

1. Instead of substituting parameters, bigU replaces the lesser dimensions 1 of its free parameter values. Here this amounts merely to multiplication, but it immediately kick-starts the engine.
2. Fundamentally bigU is powered by alternating recursive rules or wheels. Every front wheel U(a,b1) depends on an existing rear wheel U(1,b1) which in turn relies on the front wheel U(a,b) for recursion.
   Rózsa Péter calls this double recursion and proves it increases as fast as 3-wheel super-exponentiation.

Because the algorithm is so intertwined, you'll literally have no idea what you're looking at when you see a number as a function of U() and this is a good thing, for all operatorials are heinously fast. When creatures with logarithmic senses feel comfortable about Big numbers, the golden brown Buddhas of Oblivion only if ever frown |:–|

The algorithm for bigU is slightly faster than having a!b1 count factorial signs a!b.. by [!_b#a]
Though in the end it converges to this double recursion, just like super-exponentiation, but bigU achieves this in two parameters instead of three.

And so the question, whether the super-factorial !b grows with step 1 on the super-power speed-indicator ^.. [^#c] of bigE, succumbing to the same c++ beat as our other recursive operatorials towards the end, is vindicated with a big affirmative.

§4.4.1. Péter's recursion

Inspired by Ackermann's proof that primitive recursion is not the final word, Rózsa Péter continued work on the classification of recursive functions. Ackermann himself used a foundation of 3 parameters – essentially an inflated super-power function bigI – but from her hand is a basic 2-parameter algorithm, which she built to put an Ackermann φ penthouse on top (it's sometimes presented as the Ackermann recursion, though that's not historical), and which employs the same alternating double recursion as super-factorial bigU.
In this chapter we'll try to generalize Péter's Ackermann formula by putting it in bigI format. It feels like Rózsa would have sought such a translation herself, but it's not in her book.

The first thing we'll do is to reverse the direction of parameters in the functions which Péter and other recursion theorists like to use. For an intuitive understanding of the strength of parameters, we'll append every higher iterator to the right end, not to the start of the array. The last parameters create the Bigger numbers.

Here Péter's algorithm has the same recursive substituent Pé(a,b1) as we saw in the basic pair of bigU. But in bigU every parameter unit 1 in a is to be substituted (i.e. the parameter is multiplied a*v), and Péter replaces her primary parameter in one go.
Therefore Péter must at least add n=1 to the single parameter a. Else if she had put Pé(a,0) = a then every reduction Pé(a,b) [a>0] would have the same result m=1.

§4.4.2. Prefix Pe a parameter

Our operatorials do not change single parameters. The principle is that a single variable has nothing to relate to.
We'll generalize Péter's formula so that any value n can be added to its initial case. This creates a recursive function in bigO style. Because variable n has a minor effect on the result it is positioned left.

In expression Pé(1,b1) Péter's algorithm substituted v = Pé(1,b) where in bigU v = U(0,b) reduces to the smaller value b (the difference is not so significant – it doesn't happen often).
We could generalize the 2nd item in the above formula to contain all cases v = Pe(n,m,b) by prefixing another coefficient m to Pe's parameter array. Still m would remain constant, while the substituent in bigU varies during the course of the reduction.
Moreover, for a clean result m is dependent on the value of n as shown below.

First we rename the variables. The n of Pe should get the name a – note that a is not counted down.
Formula Pa is the operatorial form of Péter's recursion.

• Pa(a,b) = Pa(ab) = ab
• Pa(1,1,c1) = Pa(1,Pa(1,1,c),c)
• Pa(a,1,c1) [a>1] = Pa(a,Pa(a,m,c),c) [m:Ma(a,c)=a-k]
• Pa(a,b1,c1) = Pa(a,Pa(a,b,c1),c)

The 3d item in this definition list is newly introduced and provisional.
In the reduction of expressions Pa where a>1 and b=1 the nested inner iterator m is replaced by a-k_c where k_c<a and so 0<m<a simplifies the expression.
We still have to find out about m and leave it open for the time being. It's time to listen to the fish…

§4.4.3. Pa gone fishing

In the following 3-parameter translation Rózsa Péter's function behaves perfectly primitive recursive, as it finds expression in the super-powers of bigI.

We wrote the first parameter as a=m+k because it's not obvious what a good value for k is. (It says somewhere in our lost calculations that if a>2 then k=2 …and all will be well?!)
Keep things open with a provisional inner substituent mc:=Ma(a,c) to be determined by variable c.

It looks like we're at a loss, but it's not too bad. To continue, consider case a=2 and put m_c=1 as before.

§4.4.4. The catch-all

Fill in m_c=a-2 to translate expressions of Pa where a>2 to super-power format.

This works for all parameters c, which means we can completely translate our extension of Péter's recursion to a primitive recursive definition in bigI or bigE.
For all n>0 in Péter's initial successor formula Pé(a)=a+n the recursion keeps increasing as fast as super-powers and therefore stays below Ackermann row level.

Rewrite the basic definition of our operatorial version of Péter's recursion.

• Pa(X,0) = Pa(X)
• Pa(a) = a
• Pa(a,b) = Pa(ab) = ab
• Pa(a,1,c1) [a=1 | a=2] = Pa(1,Pa(1,1,c),c)
• Pa(a11,1,c1) [a>0] = Pa(a,Pa(a,a,c),c)
• Pa(a,b,c) = Pa(a,Pa(a,b-,c),c-) = I(2,b3,c-)--- [a=1]
                                  = I(2,b3,c)--- [a=2]
                                  = I(a,b2,c)-- [a>2]