bigΡ Reserved content

updated: 2011-09-16

# Order past Ackermann

Since Ackermann in 1928 first described a level of functions past primitive recursion, we have a model for jumping to a higher recursive class.
Grzegorczyk took a step back and classified the superpower operations ^.. in separate subclasses {K.1.c} of primitive recursion. We ventured on the road ahead.

Section 5.0.1 introduced a class of functions {K.2.0} that were grafted on superpowers, but were unable to break through the primitive recursive {K.1} ceiling on the strength of their defining rules for the first row alone. Of this testified Nn for On, and Og0 for the first proper Ackermann function Og1.
Recursive grafting of Ogd1 on Ogd covered the whole level {K.2.d.c} of Ackermann-Conway functions.

The last box stated that Conway's row of chained arrows cover the complete range and diversity of {K.2.d} level functions. This was proved in section 5.1.4.
Indeed, the current subchapter showed how bigE requires just the 4th parameter d to express Big numbers of a size otherwise expressed by an arbitrarily long row of chained arrows.

Under 2011 Construction

By recursive grafting of chained arrows on every next parameter of bigE, the whole {K.3} function class can be covered in breadth, with higher separators , in bigE representing Conway super-jumps.
This is an obvious consequence of recursive grafting, for the shoots of super-chained arrows on sublevels {K.3.d.c} relate to their stocks of row bigE or I(a,b,c,d), like shoots of Ogd on Ackermann sublevel {K.2.d.c} relate to stocks of chained arrows or E(a,b,c,d).
Proof that the first row of bigE iterates over all such countable Conway sublevels, and in particular that the next row of super-chained arrows is covered exactly by the next parameter of bigE, is given in the section below.

§5.2.3. Grafting on super-chained arrows

If we write the initial stock as a→b→→0 = a→b = E(a,b) then application of the main rule for chained arrows produces the superpowers a→b→c→→0 = a→b→c = E(a,b,c) with R→→0 the initial shoot of chained arrows, covered by E(a,b,c,d) as in the formula above.
From the next stock we will develop the next shoot of super-chained arrows, following Conway's original rules.

  • a→b→→0 = a... {a#b} = a*b
  • a→b→→1 = a→... {a#b} <~ E(a,a,a,b--)
  • a→b→→n1 = a→...→→n {a#b}
  • R→→0 = R
  • R→1→→n = R→→n
  • R→1→z→→n = R→→n
  • R→y1→z1→→n = R→(R→y→z1→→n)→z→→n

We'll work out the first shoot of super-chained arrows.

a→1→c→→n = a→→n = a→1→→n = a→→n- == a
a→b1→2→→1 = a→(a→b→2→→1)→→1 == a→(..a.)→→1 {#b#}
     <~ E(a,a,a,..a.--) {#b#} <~ E(a,a,a,..a.) {#b#}
     <~ E(a,b1,2,1,1) == E(a,..a.,1,1,1) {#b#}
a→b1→3→→1 = a→(a→b→3→→1)→2→→1 == a→(..a.)→2→→1 {#b#}
     <~ E(a,b1,3,1,1) == E(a,..a.,2,1,1) {#b#}
a→b→c→→1 <~ E(a,b,c,1,1)
a→b→c1→2→→1 == a→b→(..a→b→→1.)→→1 {#c#}
     <~ E(a,b,..E(a,a,a,b--).,1,1) {#c#}
     <~ E(a,b,..E(a,b,E(a,a,a,b),1,1).,1,1) {#c-#}
     <~ E(a,b,c,2,1)

To graft a row of super-chained arrows on n3 parameters of bigE is the same as grafting it on the preceding nth row. Grafting row upon row we'll build a super-chained square, which is fully covered by the first row of bigE.
As mentioned earlier, a square of Og is equivalent to the first row of chained arrows. Then grafting square upon square of Og turns bigE into the row of squares of Og – our erratic superpower grafting cube.

§5.3.2. Parameter stock to row shoot

The operatorial bigI with waitor needs only 4 parameters I(a,b,c,d) to cover the first row of bigE E(R), which in turn uses only 4 parameters E(a,b,c,d) for a whole row of chained arrows a→...→z, which in turn requires only a→b→c→d for the parameter row of Graham's Ôg(a,..,z) which covers one Ackermann sublevel.
Vice versa, while Og stays put, every chained arrow makes the Ackermann jump from one Ackermann sublevel to the next. But the parameters of bigE each cover a new Conway sublevel and the separators of bigI each represent a jump to the next super-chained level.
All functions share the main rule of superpowers O(a,b1,c1) = O(a,O(a,b,c1),c) but past their 3-parameter base or stock some functions increase significantly faster than others.

The translation of a Big number expression from one operatorial function to another is achieved by grafting – from a limited number of parameters to an arbitrary size row.
In general the requirements for grafting from a limited dimension to a whole dimension are:

Under 2011 Construction

  1. An operatorial function level has been constructed from subclasses, countable by a subscripted coefficient.
  2. There is a sparse recursive operatorial function (such as bigE) which employs a limited dimension (row length of 3 parameters) to iterate down these sublevels.
  3. A smaller recursive function (such as Og) covers the whole level of subclasses with a full dimension (row of parameters).
  4. The operatorial is used to graft the smaller function.
  5. With its full dimension the grafted function now covers the next level subclass.
  6. Repeated grafting covers the whole next level of functions.

# 5.4. Front row bigA

§5.4.2. Fixing the affiliate functions

Replace the third axiom of Fa to create a new function Fc which accommodates the same upload rule as bigA. We keep the zeroth axiom Fc(a,b) = ab of addition and the main axiom as it is, for b>1 and c>1.
Begin with an example case, followed by the upload rule in Fc and a restatement of the main axiom.

  • Fc(a,1,1,1) = a×1,1;1 = a×a;a = Fc(a,a,a)
  • Fc(a,1,..,1R) {1#k} = Fc(a,..,R) {a#k1}
  • Fc(a,b1,1R) = Fc(a,Fc(a,b,1R),R)

The rule of addition on the 2-tuple comes first, so the new upload axiom for Fc applies when k>0 and then it makes the first listed rule of Fa redundant too, as you can check above.

Now the remaining cases c=1 determine if the unbracketed version Fd of Fc is identical to bigA in the first row.
Because Fd depends for all its defining rules on Fc (like Fb does on Fa) via inheritance and unbracketing, we have to carefully craft ourselves a new rule for those cases of Fc where c=1.

Fc(a,2,1,1) = a×1,1;2 = a×a;(a×1,1;1) = Fc(a,Fc(a,a,a),a)
Fd(a,2,1,1) = (a×a;a)×1,1;1 = Fd(Fd(a,a,a),1,1,1)

Fc(a,b1,1,1R) = a×1,1R;b1 = a×a,R;(a×1,1R;b) = Fc(a,Fc(a,b,1,1R),a,R)
Fd(a,b1,1,1R) = (a×a,R;a)×1,1R;b = Fd(Fd(a,a,a,R),b,1,1R)

Then by adopting these new rules we come to understand how the unary subscripted operators of bigA are equal to the unbracketed variant Fd of the binary subscripted operators of Fc.

  • Fc(a,b1,1,..,1R) {1#k} = Fc(a,Fc(a,b,1,..,1R),a,..,R) {1#k a#k}
  • Fd(a,b1,1,..,1R) {1#k} = Fd(Fd(a,..,R),b,1,..,1R) {a#k11 1#k}

Now bigA's position on the Ackermann-Conway level of functions becomes clear. We can see Fd is faster than Fc and Fb, which are in turn faster than Fa, which is faster than the unmixed star *c1,R; = ^c,R; operators Fa was meant to surpass.
Because the subscripted arrows of bigE transcend their current recursive family of functions by [Under 2011 Construction] counting down the final parameter, all these operatorials move to a higher subclass in {K.3.e} with every next parameter, [Under 2011 Construction] such ordering is dependent on the comparison of bigE with chained arrows.
[Under 2011 Construction] But no more than that, because bigA is not structurally different from bigE over a row of arbitrary length – the substitution index of bigA has just been shifted one parameter to the left.

Considering that 3 parameter bigA couldn't catch up with the unmixed arrow operators of bigE, how fast is bigA compared to bigE along the first row?

Under 2011 Construction

A word on mixed majority pluxes.

I(a,2,11,1) = I(w,2,1,1) {w:I[a,1,1,1]} = I(w,2,2) =
            = I(w1,2,1) {w1:I[w,1,1]} = I(w1,I(w1,1,1)) = I(w1,w1)
            = I(w1,w) = I(w1,a) = I(w,a,1) = I(w,I(w,a-,1))
           == I(w,..I(w,1,1).) {#a-#} = I(w,..a.) {#a-#}
            = I(w,..I(a,a,1,1).) {#a--#}

# 5.5. Testing the nesting

Pair of great blue herons change nesting duties beneath a blue Californian sky

The Nirvana Sutra states that all people are enclosed by the shell of ignorance, lacking the beak of wisdom.
The Buddha comes back to this world, just like a mother bird returns to her nest, and cracks the shell so that all people, like fledglings, may leave the nest and soar into the skies of enlightenment.

Letter to Niike
Third year of Koan

§5.5.1. Shallowness of fixed receptors

The nest depth of functions with underdeveloped rules that fix the outer receptor f, remains shallow up to the point where f is replaced by an iterator (in a later moment of the reduction).
We test this with two different rules for the final iterator – the outer iterator z positioned on the right end of a function's parameter array – dropping the final iterator in function F versus its countdown in function G, with the restriction that the substituted parameter in these functions be single (not multiple) and that it stays in the same position (indexing from the left).

How many nests are there in total in F and in G, and do you think this nest depth is very significant?

  • F(a,z1) = F(F(a,z)) = F(F(F(a,z-)))
           == F(..a.) {#z11#}
  • G(a,z1) = G(G(a,z),z) = G(G(G(G(a,z-),z-),z-),z-)
           == G(..a.) {#2**z1#}
  • F(a,y,z) = F(F(a,y,z-),y) == F(..a.,y) {#z1#}
            == F(..F(..a.).,y) {F(#z#,y) F(#y1#)}
            == F(..a.) {#z1*y1#}
  • G(a,y,z) = G(G(a,y,z-),y,z-) == G(..a.,y) {#2^z#}
            == G(..G(..a.).,y) {G(#(2^z)-#,y) G(#2^y#)}
            == G(..a.) {#2^y*2^z#}
  • F(a,ti;,..) {ti;#n} == F(..a.) {#u#} where u = ti;1*.. {ti;1#n}
  • G(a,ti;,..) {ti;#n} == G(..a.) {#u#} where u = 2^ti;*.. {2^ti;#n}

In these examples the substituted parameter a stays in the same position and is not uploaded to increase higher parameters. We can tell beforehand how deep a function expression will be nested when the expression is totally reduced up to a.
Yet in both F and G these nesting rules do not appear to deliver much Bigger numbers, compared to counting down parameters replaced by self-iterating expressions as in a→b→c1→3 = a→b→(a→b→c→3)→2

We'll generalize these results for an operatorial function O(R,f,S,T) with a base or stock up to S on the left and a parameter f which is to be substituted for. Irrespective of the evaluation rules for the particular stock O(R,f,S) the nest depth is countable by the values of the parameters in T on its right, and does not exceed (is defined by) exponentiation.
Two common variations for the definition of the outer iterator are Oo(X,z) {h=0} (which drops its final iterator) and Oz(X,z1) {h=z} (which counts down its final iterator).

  • O(R,f,S,T,z1) = O(R,O(R,f,S,T,z),S,T,h)
               where Oo {h=0} and Oz {h=z}
  • Oo(R,f,S,ti;,..) {ti;#n} == Oo(R,..f.,S) {#u#}
               where u = ti;1*.. {ti;1#n} ~ (t+1)^n
  • Oz(R,f,S,ti;,..) {ti;#n} == Oz(R,..f.,S) {#u#}
               where u = 2**ti;.. {ti;#n} ~ 2^(t×n)

The two approximations use a relevant type of superpower mean x, the former the geometric mean m=1 and the latter the arithmetic mean m=0, as defined by (xi;*.. ...)*n^-.. {*#m xi;#n -#m1} in order of i.

§5.5.2. Empower those iterators

Envision an operatorial function Ga where all reduction rules are designed to sort maximum effect.
Make its definition easier to read by removing the function signs Ga and the outer brackets. In the evaluation of operatorials one type of bracket character ` should be notationally sufficient. We call this the minimal operatorial notation or minipop-format.
Use the standard variable name g for the inner iterator and h for the outer iterator.

  • Ga()
  • g,1 = gg = 2×g
  • 1,h1 = `1,h`,h == `.1,1.`,i.. {#h#}
  • g1,11 = `g,11`,1 == `.1,11.`,1.. {#g#} = 2^(g+2)
  • g1,h1 = `g,h1`,h == `.1,h1.`,h.. {#g#} ~ 2^..(g+4) {^#h}

Why is this function so fast, that it covers all superpowers with its first two parameters?
We give it a kick-start upload axiom that doubles numbers, and there is no destruction case, so all rules increase the result and that helps. But more important is that Ga counts down its iterator parameters as parsimoniously as possible. As always acceleration is continuously provided by the main iteration rules, not by the initial cases.

To peak ahead, how would this experimental operatorial Ga continue its first row?
Remember that the generic rules and especially the post-countdown axiom apply.

  • Ga()
  • g,1,..,1Z {1#k} = gg,..,Z {gg#k1}
  • 1,..,h1,Z {1#k1} = 1,..,`1,..,h,Z`,h,Z {1#k 1#k1}
                    == 1,..,`.1,..,Z.`,i,Z.. {1#k 1#k11 #h#}
  • g1,h1,Z = `g,h1,Z`,h,Z
           == `.1,h1,Z.`,h,Z.. {#g#}

The rules of recursion in an operatorial function involve the substitution of one or more receptor parameters in an expression for a reduced version of that expression. Both in the original outer expression as in the substitute inner expression an iterator parameter has to be dropped or counted down to maintain reducibility.
For the creation of Big numbers it's best to choose the lowest iterators, those that least reduce the resulting expression. In operatorials this is the leftmost available parameter, and each reduction step it is counted down by 1.
The position of the outer receptor is usually the same as the inner iterator and the outer iterator will be positioned immediately to its right.

§5.5.3. Vana expansion

A variant notation is introduced with deeply nested substitution by variables v, christened vana substitution. (Sanskrit: vâna = wind, life, a straw mat, a hole in the wall, a number of forests. So called because an expression's final aim is reduction to natural number or recursive nirvâna, which is hard to reach for a Big number ;-)

Under 2011 Construction

  • Ga(ai,..z) {ai,#r} = Ga(v1;,..) {v1;#r}
              where vk; = Ga(vk1;,..) {vk1;#r k<z}
                and vz; = Ga(ai,..) {ai#r}

bigGabber bigGabber

# 5.6. Operatorial design

# Cursed

Intense angular face with pork-pie hat and burning cigarette
Robert Oppenheimer
April 1954

Great is thy net, brave Indra, thine the mighty match for a thousand,
    Lord of Hundred Powers!
Holding them, with his host, therewith hath Indra slaughtered
    Dasyus a hundred, thousand, myriad, hundred millions.

This world so mighty was the net of Sakra, of the Mighty One:
    With this, the net of Indra, I envelop all those men with gloom.
Great weakness and misfortune, pain which words can never charm away,
    Languor, fatigue, bewilderment, with these I compass all the foes.

I give those foemen up to Death: bound in the bonds of Death are they.
    I bind and carry them away to meet Death's wicked messengers.

Atharva Veda 8.

Ever since the days of the Manhattan Project, when patriotic physicists like Oppenheimer and the sympathetic Feynman designed the Atom Bomb – the Abomination of Desolation – every honest scientist is obliged to ask himself: Can this theorem of mine be used for military purposes or exploitation?
If the answer is: Yes, even a pure mathematician should bear the consequences and refrain from publishing. Whom would you entrust this with? It's better to practice frugality, meditate and become a Sage.

With earthly resources dwindling – wood, fish, oil, phosphate, copper, water, marble, etc. becoming scarce – the time has come that the mere taking isn't enough. For our legacy to survive a different mentality must settle foot within our civilisation, or else the whole of humanity will be put back to the age of the stone axe.

The kings of the stone axe surely have no use for the gift of mathematics. But there's still danger that some other entity grimly reaps the benefits of the human mind. An operator more disciplined – ready to accept tyranny in exchange for electricity – the Dark Vaders of the future…

Nevertheless — let the rain of mathematics fall down on everyone! (not good enough:(

Designers of Big numbers must take into account the following general principles for operatorials, seen from the perspective of a row of parameters.

  1. # Definition of a parameter
    Let O = O(XpkZ) be an operatorial as usual, where the array sequences X:=X', and Z:=,Z' respectively end and begin with the declaration of a separator comma, or X or Z can be empty.
    Parameter pk at index k in the array holds a number value pk=n or an expression pk=O(Y) which can be evaluated completely – to natural number when Y consists of separators and units 1.
    Parameter arrays are constructed or defined from left to right, but reduced or evaluated from right to left. Values on the right are most important for creating the Biggest numbers.
  2. Under 2011 Construction

    # General contract for an iterator
    A parameter can function (temporarily) as an iterator as long as this can be counted down by 1.
    The number zero is an empty space, so for a parameter pk in O to be a natural iterator (in a normal non-inverse recursion) between commas, it must have a minimum value of pk>1 before countdown. Or else it can be the last parameter pn=1 in O = O(X,pn) in which case it is dropped post-countdown, to iterate down the length of the array.
    It's best to stick to simple rules for the selection of iterators, and as bigO expands from level to level bigO iteration should expand too – adapted by generalizing its basic rules.
  3. # Restriction on the range of iterators
    Operatorials O = O(Ro,Rp) where Ro = p-*k,..,p0 and Rp = p1,..,pn can reserve a single parameter constant p0 or a range of constants Ro on the left, that must not be counted down.
    For example bigE does this throughout, where parameter p0 is the passive left operand a, whose value is iterated over in operations (apart from addition) by the active right iterator-receptor b. The rules for bigE keep counting down b as q1:=p1- in substitute inner expressions O(p0,q1,p2), but never p0=a who wait for lonely separators to drop and dissolve.
  4. # Succession in << parametric order
    When in an expression O a parameter is counted down (in place), this creates a new expression P which is a parametric predecessor of O because it is parametrically smaller, write P<<O.
    The concept of a predecessor counted down is the opposite of a successor counted up – this applies to all types of predecessor << successors below.
    Big numbers often cannot practically be approached otherwise than with a specific algorithm which iterates over parameters, and thus can only be ordered by measures << of parametric order.
  5. # Definition of an algorithmic predecessor
    The algorithmic predecessor of an expression O is a unique parametric predecessor Q where the parameter counted down is the left or inner iterator ps as defined in the contract for the inner iterator.
    Within the context of a function definition, all predecessors Q are (theoretically) reducible to a natural number larger than zero Q(Y) = 1... {#q>0} = q
    When from an original expression O a rule of O has delivered the algorithmic predecessor Q, the substitution of Q in O' takes place to the left of the outer iterator pr. Before substitution you can either reduce Q==q to natural number or leave Q (for the time being) as a function expression.
  6. # Discussion of recursive substitution
    Operations of bigO are collections of evaluation rules, that transform an original (or nested original) expression O by reduction steps O->O'...->...->N {'#i O'...#x} finally to a natural number.
    Every reduction step counts down the outer iterator in Ok = O'... {'#k} and inserts a characteristic substitute Qk, which is the algorithmic predecessor of the expression Ok.
    Let O(XpsZ) be an original expression O0 where ps=m1 is the inner iterator. A recursive substitution rule of O then derives Q0 = O(XmZ) which replaces the outer receptor(s) in O1.
    In the next reduction steps substitute Qk replaces the outer receptor(s) in Ok1.
    Each substitute or nested expression Q of course will suffer its own cascade of reduction steps.
  7. # Discussion of numerical predecessors
    When an expression O = O(X) is recursively reduced (partly) to a numerical expression P parametrically larger than its algorithmic predecessor Q {Q<<P} we call the resulting expression a numerical predecessor of O.
    The natural successor of O(X) = x is the number x1, and the natural predecessor of x is x-.
    When such numerical predecessors still have O(X) as a subexpression, they cannot function as a substitute Q in a recursive substitution rule for O (except sometimes for initial cases), because O's evaluation would get caught in an irreducible substitution loop (here leading to a trivial conclusion).
    F(a,b1) = F(F(a,b1)-,b) => a1 = F(a,b) => b := 1
  8. # Contract for an inner iterator
    A left or inner iterator ps (pee-es) is a parameter from an expression O = O(Ro,p1,..,pn) which is counted down by a defining rule of O in order to create its algorithmic predecessor Q. The only a priori requirement for substitute Q is that it is parametrically smaller than O, so for an inner iterator ps=pi the rule can pick any unreserved index where pi>1 or (on the last index) pn=1, following our general contract for iterators.
    An example of bigEinner iterator b is shown in a blue square and outer iterator c in pink
    E(a,b1,c1) = E(a,E(a,b,c1),c)
    In this basic case of bigE, parameter b clearly takes the role of the outer receptor too.
    Note that the inner and the outer iterator can be chosen independently (but not the outer receptor!)
    • Maximized inner iteration – bigU counts down the first parameter ps = p1
    • Minimized inner iteration – Nn counts down the last parameter ps = pn
  9. # Contract for an outer iterator
    The position of the right or outer iterator parameter pr (pee-ar) of an operatorial O = O(Ro,p1,..,pn) is selected by the rule which is applicable, depending on whether the value of pr can be counted down. Except for all reserved parameters Ro and the parameter at the first index r=1 of O's parameter array, the rule can pick any pr>1 {r>1} or the parameter pn=1 at the last index n, following the general contract of iterators.
    For example in E(a,b) the outer iterator is b, later E(a,b,c,..) prefer the outer iterator c.
    The ban on using the first parameter for outer iteration guarantees there is always an outer receptor parameter left to substitute the expression Q for, which safeguards the reducibility of bigE.
    • Maximized outer iteration – Choose an early left parameter such as pr=p1=b
    • Minimized outer iteration – Persistently countdown final parameters pr=pn=z
  10. # Contract for outer receptors
    The substitution in expression O of its algorithmic predecessor Q, takes place (or starts) on the parameter index of the (rightmost) outer receptor pu (pee-yu), on the left of the outer iterator pr.
    The rules for O can allow this substitution to be limited to a single outer receptor or to cover a whole range of outer receptor parameters. For multiple substitution a range must be specified which can run from the rightmost index pu=pr- all the way down to the leftmost unreserved index.
    The outer receptors – noted in the singular as pu or indexed as pi {1≤i≤u} – need not come directly left of the outer iterator pr, but there is good reason to do so. For if parameter pr- wouldn't be substituted, it would just count off its original value after the outer iterator finished counting off, so the function of those two parameters could just as well be taken by one parameter pr-:=pr+pr- (addition in exchange for a parameter is a senseless waste at this stage).
    • Maximized outer substitution – Position outer receptors directly left of outer iterator pr.
      Multiple substitution helps little, it cannot even boost functions to a higher subclass.
    • Minimized outer substitution – Don't substitute multiple parameters. Lay waste a few on the right?
  11. # Parameter dropping is separator iteration
    When you iterate a final parameter down from 1 and let drop that parameter post-countdown, this is parameter dropping, the initial form of dimension dropping. A parameter (containing a series of units 1 separated by spaces) has dimension d=0, and a row (of parameters separated by single commas) has dimension d=1. By dropping a dimension d you iterate down the length of a higher dimension d1.
    We measure the types of dimensions by separator commas too, so dropping can properly be called separator iteration.
  12. # Contract for inner receptors
    This is an advanced topic, usually operatorial algorithms won't need it.
    A primary inner receptor u1 (yu-wan) is a parameter (of subexpression Q0) positioned left of the inner iterator. This inner receptor is replaced by another algorithmic predecessor of O, usually of type Q (but not exactly Q0 since Q0 has this new Q1 nested inside, clever eh?0)
    The following example rule with an inner receptor maintains reducibility (no substitution loop!~)
    F(a,b1) = F(F(F(a,b),b),b)
    Here is an original expression F = O evaluated to an outer expression F0 = O', wherein a single outer receptor u0=pu substituted for an expression F1 = Q0, wherein a single inner receptor u1=qu was replaced by an expression F2 = Q1 (all in perfect harmony:^)
    Such substitutions can be nested to an enumerable depth, which brings us the topic of vana.
  13. # Vana substitution
    We saw vana notation

  14. # Function optimization
    By careful definition of the rules for a function of bigO, the numbers that result from the recursive substitution of its expressions can become Bigger and bigger and…
    Optimization isn't the whole story – higher levels are! Besides, at some point you may be looking for extra resolution instead of extra speed and the principles presented here can help you tweak that too.
    Check the maximization and minimization remarks at the bottom of the defining contracts.
    • Example 1 – our function Nn replaces all parameters except the last, but does become Ackermann-Conway in its first row, because Nn uses the last parameter z both as outer and as inner iterator.
      This shows that function speed ultimately depends on how long the algorithmic rules postpone the countdown of the inner iterator! (long reduction = fast function = big numbers)
    • Example 2 – Conway's chained arrows substitute the penultimate parameter y for Q, which indeed expands the highest available outer receptor directly, but has a shorter reduction chain than the subscripted operators on the front row of bigE, which eventually substitute y for an enormous stack of nested substitutes Q'.. accumulated in bigE's default iterator-receptor b.
      This shows that the outer iterator pr should be positioned as far left as possible to create the Biggest numbers (so that the substitution of the outer receptor takes place at index pr-=p1).

# 5.7. Whole row of waitors in bigY

Krishna has a skin in the colour of a dark rain cloud

yasya prabhâ prabhavato jagad-andha-kothi-
kothishv ašesha-vasudhâdi vibhûti-bhinnam
tad brahma nishkalam anantam ašesha-bhûtam
govindam âdi-purusham tam aham bhajâmi

I worship Govinda, the primeval Lord, who is endowed with great power. The glowing effulgence of His transcendental form is the impersonal Brahman, which is absolute, complete and unlimited and which displays the varieties of countless planets, with their different opulences, in millions and millions of universes.

Hymns of Brahma 40.

The definition of front row bigY.

  • Y(R,x,y1,z1)= Y(R,w,Y(R,x,y,z1),z) {w:Y[R,x,1,z]}
  • Y(R,Y[S,1,z],y)= Y(R,Y(S,y,z))

Under 2011 Construction

# 5.8. Super-factorial row bigU

The definition of front row bigU.

Under 2011 Construction

# 5.9. Algorithms over the first row

Old photograph of a Chinese family below a 14-storey pagoda

Once, Confucius was taking part in the winter sacrifice. After the ceremony was over, he went for a stroll along the top of the city gate and sighed mournfully. He sighed for the state of Lu.

His disciple asked: "Why should the gentleman sigh?"

Confucius replied: "The practice of the Great Way, the illustrious people of the Three Dynasties – these I shall never know in person. And yet they inspire my ambition!
When the Great Way was practised, the world was shared by all alike. The worthy and the able were promoted to office and people practised good faith and lived in affection. Therefore they did not regard as parents only their own parents, or as children only their own children..."

"Now the Great Way has become hid and the world is in possession of private families. Each regards as parents only his own parents, as children only his children. Goods and labour are employed for selfish ends."

Book of Rites

under 2009 construction ~ OBSOLETE!

Algorithmic computer programme (a design in 24 hours doc) for the first row of bigI:

  1. Let I = I(p1,..,pn) be an expression of bigI.
    First handle the special initial cases where the number of parameters is n≤2
    These are the only lines where natural numbers are created in the routine of bigI.
  2. Case C0 – length n=0 has as return value 0
  3. Case C1 – length n=1 returns the value of parameter p1
  4. Case C2 – length n=2 check if the second parameter p2 has the value 1 and if yes,
    then let drop that second variable p2:=0 and the trailing comma to double the value
    in place I'(p1p1) and take one more step, or just return the resulting number p1p1
    If not, then we have I = I(a,b) {b≠1} which can continue normally.
  5. Create a copy J = J(q1,..,qn) from the expression I
    This is not really necessary – only limited data needs to be passed – but it's instructional.
  6. Scan expression J from left to right, starting at the first parameter index 1
    until you find a parameter value ql≠1. This will function as left or inner iterator.
  7. Fork F0 – If you've found the inner iterator ql>1 store its position L {0<L<n1}
    Then count it down by substituting ql' := ql- on index l in J'
  8. Fork F1 – Else you've come to J's right end, because all parameters are qi=1
    Then countdown the last parameter qn':=0 and drop it, also drop trailing commas.
  9. F1 – Store the new last position as index L:=n- of the inner iterator.
  10. F1 – Fetch the value of q1' and substitute it at index l in J' by doing ql':=q1'
  11. F1– Store the last index as the position of the outer iterator R:=n
  12. The reduced expression J' now is the minimal algorithmic predecessor of I
    and I is the minimal algorithmic successor of J' (or the next Big number).
    Countdown final parameter pR':=0 and drop it from I' and also drop trailing commas.
  13. F0– Scan the original expression I from left to right, starting at index L1
    until you find a parameter value pR≠1. This will function as right or outer iterator.
  14. F0 Fork F2 – If you've now found a parameter pR>1 store its position R {L<R<n1}
  15. F0 Fork F3 – Else you're at I's right end, and all parameters {i>L} right of index l
    have the value pi=1 and so you fall back on ps≠1 and store its position in R:=L
  16. F0 End F2 F3 – Decrease the outer iterator by substituting pR' := pR- on index R in I'
  17. End F0 F1 – The index where I' must substitute for J' is always given by S:=R-
  18. Here J' is never a natural number, so substitution of J' in I' is postponed.
    Store index S and a binary prepared string I' (or its mutation data) on top in the stack.
    (with the provision your system manager tells you he still has enough computer memory!)
  19. Recursion – The memory stack increases its length by one Q':=Q1
    You now take the next recursion step, call a new routine where I'':=J'
  20. Returns – The J' the recursion returns here is a natural number, so the value
    pS' := J' can now substitute for the parameter pS' at index S in I'
  21. With a stack trace {Q>0} return the result of the next bigI routine for I'
  22. If the stack trace is down to {Q=0}, output the result number J' and exit the programme.
    Take care: the stored data could theoretically grow larger than the numbers expressed.
  23. Recursion – You could also opt to print out a string of characters when ready, that is
    when substitution of the whole stack of expressions produces a string with a minimal size P
    Given a current stack length Q this can be estimated as Q*(pi...n) {pi#n} ~ P
    but it would be better to keep count of the prepared string lengths in a global total.
    If size P is reached, recursively substitute the strings J' in I'.. at positions S..
    and apply the appropriate function tagging under way. Print out the intermediate result.
    You can now terminate the programme, or continue with a clean stack just for I:=J'

The definition list for bigI below describes the case of 3 parameters as an example of the more general case for arbitrary many parameters on the first row, which follows later.
The notation with underlined parameters in the rules and positional meta-information is meant to support the algorithmic programme outlined above.

Left or inner iterators are underlined in the rule's substitute expression (within brackets).
Right or outer iterators are underlined in the rule's original expression (before use).

Definition lists and the types of list markers were described in chapter 4.
Again we've removed function signs I and the outer brackets for readability.

The meta-information in curly brackets gives the parametric positions in O of:
the Left {L__} iterator and the Right {_R_} iterator and the Substitution index {__S}
Their position numbers are ordered: L ≤ R & R > S.

  • I():  1,1,1    = 1,(1,1)         {232}
  • I():  a1,1,1   = a1,(a1,a1)      {232}
  • I():  1,b1,1   = (1,b,1),b,1     {221}
  • I():  a1,b1,1  = (a,b1,1),b,1    {121}
  • I():  1,1,c1   = 1,(1,1,c),c     {332}
  • I():  a1,1,c1  = a1,(a,1,c1),c   {132}
  • I():  1,b1,c1  = 1,(1,b,c1),c    {232}
  • I():  a1,b1,c  = (a,b1,c),b,c    {121}
  • I():  1,1,1,1   = 1,(1,1)             {232}
  • I():  a1,1,1,1  = a1,(a1,a1)          {232}
  • I():  1,b1,1,1  = (1,b,1),b,1         {221}
  • I():  a1,b1,1,1 = (a,b1,1),b,1        {121}
  • I():  1,1,c1,1  = 1,(1,1,c),c         {332}
  • I():  a1,1,c1,1 = a1,(a,1,c1),c       {132}
  • I():  1,b1,c1,1 = 1,(1,b,c1),c        {232}
  • I():  a1,b1,c,1 = (a,b1,c),b,c         {121}

Ψ.6. Dimensions Under 2011 Construction

§6.0.1. Section title

§6.0.6. Comparing speeds

Different dimensional jump methods result in different speeds. Tell when each operatorial catches up with another, given a specific jump method (in left column).

  front row
Ôg E I Y
1-A. E U/I Y  
2-E. I U/Y    
3-I. Y      
4-U.       example table

Under 2011 Construction

# 6.2. Extended array functions

§6.2.1. Means that matter

We still have to figure out what rules contribute to the propagation of the species and what rules are like junk DNA. Which rules can be dropped and which rules modified for a definition list to be more concise and aesthetic? Which part of an axiom can be dispensed with, so expressions do not increase significantly slower and the axiom works out just as effectively?

For the following definition of an extended array function (EAF) we simplified BEAF's 7 axioms for dimensions from section 6.1.3. We made sure to gain a little pace, just for sports, but essentially the bigO strength of this EAF is equal to Bowers' dimensional arrays.
Instead of inline separators [n] we count commas ,.. {,#n1} or ,n; here. And because , is equal to ,0; two rules could be merged in axiom 5 of this definition list for, let's call it Deoxy's EAF.

  • DEAF ()
  • a,b = 1,-;...., {,-;..#b #a}
        = a,-;.... {,-;..#b- #a} = a^b {,-:0*}
  • a,1,Z = a
  • A,1,,Z = A,,Z
      so  A,1 = A (when Z=0 because X,=X)
          a,,Z = a (reconciles axioms 2 and 3)
  • a,b,m;1,..,2Z {1#k1} = a,b,m;1,..,b1,1Z {1#k} (work out!)
                       == a,b,m;b1,b,..,1Z {b#k}
                   {m:0}= a,(..a.),b,..,1Z {#b-# b#k1}
                   {m>0}= a,....,b,..,1Z {,..#m #b b#k1}
  • a,b1,2Z = a,(a,b,2Z),1Z
  • a,b,n1;2Z = a,....,1Z {,..#n1 #b}

Now the question is whether the improvements put forward by the 3 Gods...
Try to merge with rule 2!!!

Under 2011 Construction

§6.2.2. Section on EAF

Under 2011 Construction

# 6.3. Induction over dimensions in bigA

The rule of induction over dimensions is the amazing yardstick of the Apexer function.

A(a,..1) {,#k1} = A(a,.. ...) {,#k a#a}

bigΨ.III. Systems of Characters

Ψ.7. Extra-dimensionality

§7.0.1. Power tower boxing

Colourful 3-dimensional box filled with numbers 3,3,3,,3,3,3,,3,3,3,,,...

A rajah of an east Indian country invited the 27th Buddhist patriarch Prajñâtâra to a feast. The rajah asked him, "Why don't you read scripture?"
The patriarch said, "This poor wayfarer doesn't dwell in the realm of the body or mind when breathing in, doesn't get involved in a myriad circumstances when breathing out. I always reiterate this very scripture, hundreds, thousands, millions of scrolls!"

Book of Serenity 3.

What + * ^ were for superpower operators, are parameter => row => dimension for non-functional (empty) separators.
Extra-dimensional expressions have been here all along, disguised as primitive recursive functions. This subchapter studies the empty , comma that does nothing but separate and naturally adds separated series of units 1... or number items.
These commas ,.. can be counted and used to notate repetitions of properly stacked items. We construct, through recursion by example, an elementary dimension box of the number a to the power a-1

1,.. ... {,#0 #a} = 1... {#a} = a (number item a)
a,.. {#2} = a,a, = aa = a*2 (series include a trailing comma)
a,.. {#b} = a*b := a**2 {b:a} (row of items a of length b)
a**2,,.. {#b} = a*a*b := a**3 {b:a} (square of size a*b)
1,.... {,..#c1 #a} = a**c,.. ... {,#c #a}
                  := a**a {c1:a} = a^^2 (dimension box)

Initial commas ,1; are written , without subscript. The double ellipsis .... spawns sequences by dual repetition.

Introduce subscripts to typify our empty ,S separators starting with ,d; {d:1} = , as worked out above.
Again we construct series of items a up to size b dimensions, where c functions as comma or dimension counter. From the perspective of multiple arrays the comma types where d=2 open up the extra-dimensional realm.

a^a,2;.. {#b} = a^a*b := a^a1 {b:a}
a^ac-,2;.. .. {,2;#c #a} = a^ac := a^aa {c:a}
a^aac-,3;.. .. {,3;#c #a} = a^aac := a^(a*3) {c:a}
a^(a*d-)c-,d;.. .. {,d;#c #a} = a^(a*d-)c := a^a^2 {d:a c:a}

Only the highest valued subscripts ,n;.. in sequences ,i;.. .. {,i;..#n} bear significance. This fact implies that the commas in our construction are not considered to be mixed (in ascending order from left to right).
After the single subscript ,a;.. we continue with two ,a,b;.. and then the first row ,R; of subscripted coefficients.

a^a^2,a,1;.. {#b} := a^(a^2)1 {b:a}
a^(a^2)c-,a,1;.. .. {,a,1;#c #a} := a^(a^2)a {c:a}
a^(a^2)ac-,a,2;.. .. {,a,2;#c #a} := a^(a^2)aa {c:a}
a^(a^2)(a*d-)c-,a,d;.. .. {,a,d;#c #a} := a^(a^2*2) {d:a c:a}

a^(a^2*2)(a*d)-,a,a,d;.. .. {,a,a,d;#a #a} := a^(a^2*3) {d:a}
a^(a^2*e)-,a,..;.. .. {a,#e ,a,..;#a #a} := a^a^3 {e:a}

There's something peculiar about the way we build this structure here – the new subscript dimensions behave like (the previously defined) number dimensions, in the sense that an already defined parameter ,a; is never reset. It keeps counting forward in every new construct, only the value of the final (and deepest) parameter increases.
The meaning of this is discussed later.

Now we've stretched out the comma types from a single coefficient d to a row of types of length e, subscripts can be extended to a nested dimension box, by declaring their commas as countable. Again, by appending trailing commas, we separate the dimensions of arrays of items and sizes, all constructs with value a.

a^a^3,S;.. {S:a,..,1 #a #a} = a^(a^3)1
a^a^3,S;.... {S:a,..,1 #a ,S;..#a #a} = a^(a^3)a
a^(a^3+a^2)-,S;.. .. {S:a,..,a #a ,S;#a #a} = a^(a^3+a^2)
a^(a^3*2)-,S;.. .. {S:a,..,.. #a #2 ,S;#a #a} = a^(a^3*2)
a^(a^3*a)-,S;.. .. {S:a,..,.. #a #a ,S;#a #a} = a^a^4

a^(a^4+a^2)-,S;.. .. {S:a,..,..,a #a #a ,S;#a #a} = a^(a^4+a^2)
a^(a^4*2)-,S;.. .. {S:a,..,..,.. #a #a #2 ,S;#a #a} = a^(a^4*2)
a^(a^5)-,S;.. .. {S:a,..,..,.. #a #a #a ,S;#a #a} = a^a^5

a^(a^c),S;.... {S:a,....,1 ,..#c-- #a ,S;..#a #a} = a^(a^c)a
a^(a^c1)-,S;.. .. {S:1,.... ,..#c #a ,S;#a #a} := a^^3 {c1:a}

The subscripted type dimension counter c appears as the comma counter c reincarnated.
Add all values a between commas ,S and the result is a power tower with just 2 exponents.

§7.0.2. Deep tetration nesting

Store the subscript sequence S:=1,.... {,..#a- #a} from the last equation above.
Use the wildcard P to abbreviate predecessor subexpressions on the left of each equation.
For example a^(a^a*a-)*a^(a^a)- is predecessor of a^a^a1 in the 3d line below.
Now subscript the commas inside the comma subscripts, a type nesting of 2 floors deep.

P,T.. .. {T:S,1;a ,T#a #a} = v*a^a^2 {v:a^^3}
P,T.. .. {T:S,1;S ,T#a #a} = v^2
P,T.. .. {T:S,1;.. #a ,T#a #a} = v^a = v\1 (backslashing)

P,T.... {T:S,1;..,1;S #a ,T..#a #a} = v^a1
P,T.... {T:S,1;..,1;.. #a #a ,T..#a #a} = v^a^2 = v\2
P,S2:: {S2:S,1;:: ,1;..#a #a ,S2..#a #a} = v\a = a^a^(a*2)

Since we fell through to the 2nd floor of nesting, our notation became a little more abstract. We've abbreviated the repeated repetition .... as :: a dimension box.
And the corresponding repetition statements inside the meta-brackets can be taken for granted, as we let the pattern P,T:: = P,T.... {,T..#a #a} for all subscripts T continue.

P,T:: {T:S2,2;S2} = (v\a)^2 {v:a^^3}
P,T:: {T:S2,2;.. #a} = v\a1
P,T:: {T:S2,2;..,2;.. #a #2} = v\a2
P,S3:: {S3:S2,2;::} = v\aa = a^a^(a*3)
P,Sa:: {Sa:Sd-,d-;:: d:a} = v\*a = a^a^a^2

This 2nd nested comma coefficient d appends an exponent ^2 on top of dimension box v of the 1st type floor. We saw the same phenomenon when we started nesting, a typed comma higher up.
Next the 2nd nested front row appends an exponent ^3 on top of v and after that the 2nd dimension of subscripts reaches :: completion.

P,Sa,1;:: {Sa,1:Sa,a;::} = v\*a1
P,Sa,a;:: {Sa,a:Sa,a-,a,a-;::} = v\*aa
P,Sa,..;:: {Sa,.. #a:SP',P';::} = v\*a^2 = a^a^a^3
P,Sa,..,..;:: {Sa,..,.. #a #a:SP',P';::} = a^a^a^4
P,S1,::;:: {S1,:: ,..#a- #a:SP',P';::} = a^^4

Thus it is shown (a formula is abstracted below) that with each deeper level of commas the next power tower a^^n is erected. The stages of construction are clear – a single coefficient appends ^2 and every next dimension (row, square, etc.) appends another number until ^a completes the dimension box :: and the whole process is transferred to the next level of nesting.

We can let this process of comma ,TS.. typing sink down to arbitrary subscript nest depth.
The number of systematically stacked ones 1.. in the ultimate depth structure totals a^^a

Starting from the unit 1 we've so far introduced 4 structural principles on the path of superpowers.

  1. Repetition by #a adds up to numbers a
  2. A single comma produces multiplication a*b
  3. Allowing countable commas equals powers a^b
  4. Nesting to arbitrary depth results in tetration a^^b

Put a = 1.. {#ω} and stack this uncountable series of ones tetratively to get Cantor's ε0 = ω^^ω

§7.0.3. Exploring the structure

After the first row of subscript parameters we've noticed that the value of comma coefficients is not reset to 1, but kept, and that the subscript arrays only grow by increasing final parameter values.
However, that each comma has a single parameter as comma-type enumerator is more important than where that enumeration happens – here in particular on the right deep end of every array. For example, a structure where the leftmost subscript parameter is always used as an enumerator and every next position is filled with an immutable value 1 has the same capacity, so the resulting numbers should be equal.

Irrespective in what position the enumeration takes place, when a comma is repeated ,.. and valued ,d; once for each of its coefficients, it is enumerated a^2 times per parameter. We call this property double enumeration.
Then a row of parameters will enumerate a^3 different comma sequences and a dimension box of the same sizes a^a2 sequences. Slowly it becomes clear that double enumeration (value times repetition) is subordinate to the structure with multiple dimensions. This is illustrated by the fact that a subscripted dimension box of sizes a filled with values 1 for single (unrepeated) commas still delivers some a^a different comma types.

In the preceding sections we've worked out dimension boxes of the 1st, 2nd and 3d level. Each nesting level is defined to have a-- dimensions of size a for a full box to contain a^a-- parameter positions.
The first value covers the previous box (in the 3d box example this is shifted forward), leaving the first parameter with a- free values. Every other position is build up from 1 to value a and from then on stays fixed, so there are (a^a-)- new coefficients or comma types. A comma is repeated a times and kept fixed and unmixed, a total of (a^a)(-*a) different comma sequences.
Every such sequence separates a copies of a current number within the frame of a single next sequence. We open with an n- level number, which is the volume a^^n we inherit from the previously nested dimension.
We let the initial number be v0 = a and build the first level dimension v1 = a^^2 from it. Then a cascade of subscript constructions one nested inside the other sets off a power tower of comma sequences.

From these abstract construction principles the total volume vn of every new nest box can be calculated directly.
The dominant feature of this tetrative structure is that repetitions of repetitions (powers) are nested.

vn1 = a^^n * a^(a^^n)(-*a^^n-) = a^^n1

The tetrative structure with its additive commas is just the embryo in the extra-dimensional womb. To proceed we could introduce new principles, such as a vertical comma ;; that separates subscript depths or depth boxes, just like the single ; can be thought to separate the different levels of nested subscripts or dimension boxes.

Find a way to count those semicolons ;.. {#a} and to subscript them to arbitrary depth, how far would that go? If we acknowledge that the separators , ; are the first in a series of enumerable character signs (further explained in subchapter 7.1) and then introduce the extra depth-separator signs :4 .. :a :a,1 .. what kind of functions do these cover?
We conjecture that each newly introduced principle can lift the resulting expression only to the next superpower. Remember that all comma types are additive (empty), not mixable, and that only the value of the final parameter specifies the type of comma. Due to this lack of functionality the expansion of the result remains rather slow (is tetrative), but then deeper structures more quickly come into view and are easier to study.

Ludolph van Ceulen, professor at Leiden University, etching
Ludolph van Ceulen

Elaborating on our previous remarks, we expect the deep countable character codes :cS to result in a^^a^^2 and by opening another depth cycle :aS,T we think this covers the function of pentation a^^^b. But this is just a guess.
Someone else please work this out, it is beyond our means, but shouldn't be more difficult than say, calculating a polygon with 2^62 sides was for fencing master Ludolph van Ceulen, who found the first 35 decimals of Pi doing so, at the turn of the 17th century.

All operatorials bigO in this book attach functional meaning to operators in a structure where these are counted and thereupon nested. Likewise we can read the tetrative commas defined above as operators or parameter separators within an operatorial function.
Simply start to multiply with ,, and then after a such operations ,,, can function as powers, etc. So that the length of a series of separator commas ,.. {,#c1} defines the superpowers *.. {*#c} and following this subscripts in the style of bigE (unmixed) or bigI (mixed).

Properties of the example structures put forward here.

  • Numbers in between empty separators ,X = , are added.
  • All repetitions m,X {#n} = m*n are about the same size n~a

Because it takes a dimension to turn addition into powers and deep nesting of subscripts is at most good for tetration, higher order grafting initially looks like a waste of effort.
The resulting numbers are hardly superior to those grafted row upon row by Graham's Og. Starting from Ôg- as the series a.. {#b} the next graft covers superpowers with the row of Ôg0 (3d parameter of Ôg proper). Successive grafts approximate the parameters of Conway's chained arrows as was shown in chapter 5.1.4.

Common structural properties of operatorial functions.

  • To expand a separator sign we can count, subscript and then nest it.
  • Smaller signs, depths, dimensions and sizes start at the upper right.

Concluding, we've reached tetration a^^b with a series of nestable commas, which were all inherently empty (defined as addition) on purpose. Our motive was to investigate a higher order grafting, to use a dimension box or depth structure as the stock of a grafting cycle – functional definition upon functional definition. Our first impression, stated in this section, is that building from tetration isn't much faster than building from multiplication.

Now we'd like to see what happens if in the same structure with counting and nesting these subscriptable commas are declared mixable and all subscripted parameters keep functioning as active coefficients (multiple enumeration).

§7.0.4. Mixing typed commas

Reiterate the dimension box a^^2 for plain, empty, countable commas. Show next separator commas  trailing.
Let the first comma ,1; be , the unsubscripted separator. This allows the unit 1 to be coded by ,0; or by ,; to be precise, and the integer numbers a = 1.. = ,;.. as series of these.
Keep in mind that every comma with nestable subscripts needs a depth delimiter ; when spatial cues are absent (in ASCII text). Officially we should write ,1; for every non-typed , separator.

a,.. {a#a} = a^2 ,,
a^2,,.. {a^2#a} = a^3 ,,,
a,:: {,..#a- #a} = a^a-,.. .. {,#a- a^a-#a} = a^a ,.. {,#a}

Define ,n;.. {,#a} := ,n1; and construct the first coefficients for mixed subscripts with empty, additive commas. As before, P holds the place of a predecessor subexpression.

P,2;.. {P#a} = a^a1 ,2;,
P,2;,.. .. {,#a- P#a} = a^aa ,2;,2;
P,2;,2;,.. .. {,#a- P#a} = a^(a*3) ,2;,2;,2;
P,2;.. ,.. .. {,2;#a- ,#a- P#a} = a^a^2 ,3;

The possible ordering of mixed commas has no special significance. Each subsequence ,x,y can be changed for ,y,x and a sequence of subscripted commas is usually shown in order from large to small. This is the same convention we've applied earlier to the mixing of minority stars.

P,3;.. {#a} = a^(a^2)1 ,3;,
P,3;,.. .. {,#a- P#a} = a^(a^2)a ,3;,2;
P,3;,2;,.. .. {,#a- P#a} = a^(a^2)aa ,3;,2;,2;
P,3;,2;..,.. .. {,2;#a- ,#a- P#a} = a^(a^2*2) ,3;,3;
P,3;,3;,2;..,.. .. {,2;#a- ,#a- P#a} = a^(a^2*3) ,3;,3;,3;
P,3;..,2;..,.. .. {,3;#a- ,2;#a- ,#a- P#a} = a^a^3 ,4;

In our overview of the evolution of mixable comma subscripts, we merely express certain noteworthy stages of construction. Sufficient information rests in the number result on the right and the type of comma T that follows after.
So we update our notation and skip the subexpression P,Ti;.. .. .. {Ti#a- .. P#a} which can be inferred from the next comma sequence T.

a^(a^3)1 ,4;, => a^(a^3)a ,4;,2; => a^(a^3+a^2) ,4;,3;
=> a^(a^3*2) ,4;,4; => a^a^4 ,5;

a^(a^4)1 ,5;,1; => a^(a^4)a ,5;,2; => a^(a^4)(a^2) ,5;,3;
=> a^(a^4)(a^3) ,5;,4; => a^(a^4*2) ,5;,5; => a^a^5 ,6;

a^(a^p)(a^q) ,p1;,q1; {q<p1<a1} => a^^3 ,a1;

From these examples the formula for the progression of mixed commas with single coefficients can be understood. It fills a power tower with two exponents.

a^(a^ki*mi+.:.) ,ki1;.. .:. {a^ki*mi#n ,ki1;#mi ,ki1;..#n
                    under  ki1<ki1 ki<a mi<a n<a}

Mixed commas cover a^a^a by commas with single coefficients. Without mixing this is reached by the nesting of a whole dimension box :: of subscripts, where single coefficients ,d.. express just a^a^2.

Put ,a1; := ,1,1; to create the next power towers by multiple enumeration, which means all earlier parameters are reset to value 1 when the next position is appended to the subscript array. Then mix in single typed commas again.

a^(a^a+m) ,1,1;,.. {,#m} => a^(a^a+a) ,1,1;,2; {m:a}
a^(a^a+a^a-*m) ,1,1;,a;.. {,a;#m} => a^(a^a*2) ,1,1;,1,1; {m:a}

a^(a^a*n) ,1,1;.. {,1,1;#n} => a^^3\1 ,2,1; {n:a}
a^^3\n ,2,1;.. {,2,1;#n} => a^^3\*2 ,3,1; {n:a}
a^^3\*n1 ,3,1;.. {,3,1;#n} => a^a^a^2 ,4,1; {n:a-}
a^a^(a^2*n) ,4,1;.. {,4,1;#n} => a^a^a^3 ,5,1; {n:a}

a^a^(a^a-*n) ,a1,1;.. {,a1,1;#n} => a^^4 ,1,2; {n:a}

Mixed commas cover a^^4 with 2 values, namely the subscripted ,a; and ,a1,1; coefficients.
When we'd retain coefficient values (apply double enumeration) this would take 2 whole parameters, and by retaining without mixing this power tower is reached by the 2nd full nest or 3d :: dimension box.

§7.0.5. Mixing a row of commas

a^^4^2 ,1,2;,1,2; => a^a^(a^a)1 ,2,2;
a^a^(a^a)a ,3,2; => a^a^(a^a+a^2) ,4,2;
a^a^(a^a+a^3) ,5,2; => a^a^(a^a*2) ,1,3;

a^^4\1 ,2,3; => a^^4\*2 ,3,3;
a^^4\^2 ,3,4; =>

§7.0.6. Mixing squares of commas

# 7.1. Character types

§7.1.1. The significance of depth

What actually happens on the level of character signs, when we nest commas ,X.. as typed separators?
While for the human eye the lowered red X bears the intuitive meaning of moving to a deeper level, a computer would have to be pointed exactly to the start and end of the nested sequence. This requires at least one depth delimiter assigned to each comma.
We use the semicolon ; to signify the end of a sequence (in computer languages ; terminates a programming statement). Here the number of non-terminated commas a,b,c,;d,;x;y;z shows the nest depth from left to right (or vice versa the number of free semicolons counts the depth from right to left).

If we wouldn't delimit every single comma (either by vertical or semicolon nesting), commas couldn't be typed to arbitrary depth. Plain untyped commas can be written as ,; or ,1; to support a system where commas can have more than just a single coefficient, but where spacial cues are forbidden or not good enough.
Perhaps a particular rule would specify a maximum depth beforehand, so that the deepest level of commas need not be delimited. Then we can render the previous example as a,b,c,d,x;y;z

In an algorithm where a single extra-dimensional coefficient suffices, subscripting is one level deep. By letting such shallow subscripts rule, our notation need not bother with untyped commas. As in a,b,c;d,,z where a comma followed by a number and a semicolon qualifies as a typed comma.
In fact we can rid our notation of the extra character ; altogether, by appending after every comma a number (coefficient) and an extra virtual comma (delimiter). As in a,1,b,c1,d,,1,z (note that, without mixing rules for subscripted commas ,c,c, and ,,c, are equal), where the even parameters are the subscripted coefficients.
Both notations can be extended to a row of subscripted parameters of fixed length, but no further. This might be the maximal unmixed two character arithmetical structure (outside of the hyper-character hierarchy). And this maximal binary structure is minimally represented by the tetrative power tower a^a^3 = 256 {a:2} of 8 bits is 1 byte.

Do we care more about an extra single character or about an array of unnested commas? From the context sketched above it looks like both notation devices wield the same descriptive capacity.

A character sign which denotes the property depth is an invitation to start counting and subscripting and nesting it. Before the semicolon ; that just popped out from under the hood is subjected to this, a few remarks in advance:

When an algorithm doesn't allow mixing of character subscripts, then all ;S;X = ;X;X subsequences can be notated as ;;X as we saw before with the unmixed ^X arrow operators, and above with the unmixed ,X.. commas of the tetrative structure.
Without mixing, explicit counting is not necessary. The character counter in question should be prefixed in the position of the first subscripted coefficient, where it functions perfectly well in its new guise as the initial holder of type values for the character.
Of course, the initial subscripts of the previous paragraph benefit from a notation without extra ; semicolon and we can still simply count their , commas.

If we can have none and can have one, then we can also have plenty: that's what recursion's about! So the option to mix subscripts or not to mix them, should be extendible to multiple mixing. And this can be achieved by employing multiple counters.
Being able to mix a row of subscripts on the strength of a single counter dominates the expansion of a structure much more than an extra subscripted parameter would. This was first shown in chapter 3 by comparing the expansions of two operatorial functions – bigI's stars versus bigE's arrows. Because our goal is to create Big numbers, the well mixable minority stars *X.. {*X#c} win from the poorly or not mixable majority arrows ^c,X

But without subscripts no mixing is possible, all types are the same. There must be some optimum number of counters and coefficients for every operatorial algorithm – in a situation where you have to choose one axis against the other, this can be plotted in a graph.
Luckily we're allowed an arbitrary number of coefficients and we've worked our buttocks off to expand those to untold dimensions. So the exercise is: how to define multiple counters of subscripted separators?

It's easy! Visualize a rectangular array, where two counters create a*b possible mixed signs (no matter what sign, use ,;0). Then expand that vision to a row of counters a,.. {#b} with a dimension box a^b full of mixed signs. Pretty soon your counters will stretch over multiple dimensions and their separator commas might even become subscriptable (and mixable2;!) themselves.
But wait, hold back now, how does the dual counter case a,;b actually work?

Under 2011 Construction

§7.1.2. An enumeration of signs

Again, except for plain counting of ;.. semicolons, the new generation of depth subscripts requires a new character to terminate its nested arrays. And looking at the keyboard at hand we seem to run out of them, so it's time to count characters. How do we do that?

A new notation which includes all characters is introduced.
We call these the first hyper-characters in our hyper-character hierarchy, which is closely related to the hyperarithmetical hierarchy of Turing machines.

  • :1 = 1 Initial unit, counts numbers
  • :11 = , Separator of numbers, counts array dimensions
  • :111 = ; Delimiter of separator subscript nest depth, counts the initial depth-type
  • :1111 Delimiter of depth-type subscript nesting cycles, counts some even more elevated?
  • :1.. {1#ω} The Gog character, the first hyperarithmetical infinity

Now use items ω instead of 1 and put them in an operatorial construction of bigI expanded up to the Gog character.
That number is the Magog number or character or hierarchic subscriptable, mixable, etc. counter, know what I mean? Zero cycles of these and you end up with naught, ha!

Bend the rules slightly, zero by one, and hey presto!!

# 7.2. Dimensional grafting

§7.2.1. Theorem of BEAF

Under 2011 Construction

Bowers' inline dimension separators [Ri].. .:. can be counted and mixed – this they have in common with our subscripted commas ,Ri;.. .:. which evaluate differently (are persistent and therefore much faster).

Bowers defines extra-dimensional expressions of BEAF through nesting standard dimensional arrays.
In the games played to create Big numbers precision (or resolution) succumbs to tools that zoom out faster – as we have the extra-dimensional enumerators of bigO that reapply the previous array to count dimensions directly.

Ψ.8. Creating characters

§8.0.1. New rules

1.. {1##2} = I(1..,.. ...) {1#l ,#o 1..,..#k}