“Ik heb een potje met vet
al op de tafel gezet...”
bigΡ
bigΡ Reserved content
updated: 20110916
# 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 AckermannConway 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 superjumps.
This is an obvious consequence of recursive grafting, for the shoots
of superchained 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 superchained arrows
is covered exactly by the next parameter of bigE,
is given in the section below.
§5.2.3. Grafting on superchained 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 superchained 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 superchained arrows.
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 superchained arrows on n3
parameters of bigE
is the same as grafting it on the preceding n
th row.
Grafting row upon row we'll build a superchained 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 superchained level.
All functions share the main rule of superpowers
O(a,b1,c1) = O(a,O(a,b,c1),c)
but past their 3parameter 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
 An operatorial function level has been constructed from subclasses, countable by a subscripted coefficient.
 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.

A smaller recursive function (such as
Og
) covers the whole level of subclasses with a full dimension (row of parameters).  The operatorial is used to graft the smaller function.
 With its full dimension the grafted function now covers the next level subclass.
 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 2tuple 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
AckermannConway 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.
# 5.5. Testing the nesting
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.
–
Nichiren
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,t_{i;},..) {t_{i;}#n} == F(..a.) {#u#} where u = t_{i;}1*.. {t_{i;}1#n}
 G(a,t_{i;},..) {t_{i;}#n} == G(..a.) {#u#} where u = 2^t_{i;}*.. {2^t_{i;}#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
selfiterating 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,t_{i;},..) {t_{i;}#n} ==
Oo(R,..f.,S) {#u#}
_{ } where u = t_{i;}1*.. {t_{i;}1#n} ~ (t+1)^n 
Oz(R,f,S,t_{i;},..) {t_{i;}#n} ==
Oz(R,..f.,S) {#u#}
_{ } where u = 2**t_{i;}.. {t_{i;}#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
(x_{i;}*^{.. }...)*n^..
{*#m x_{i;}#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 minipopformat.
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 kickstart 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
postcountdown
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(a_{i},..z) {a_{i},#r} =
Ga(v_{1;},..) {v_{1;}#r}
_{ } where v_{k;} = Ga(v_{k1;},..) {v_{k1;}#r k<z}
_{ } and v_{z;} = Ga(a_{i},..) {a_{i}#r}
# 5.6. Operatorial design
# Cursed
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.

#
Definition of a parameter
LetO = O(Xp_{k}Z)
be an operatorial as usual, where the array sequencesX:=X',
andZ:=,Z'
respectively end and begin with the declaration of a separator comma, orX
orZ
can be empty.
Parameterp_{k}
at indexk
in the array holds a number valuep_{k}=n
or an expressionp_{k}=O(Y)
which can be evaluated completely – to natural number whenY
consists of separators and units1
.
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.  Under 2011 Construction
# General contract for an iterator
A parameter can function (temporarily) as an iterator as long as this can be counted down by1
.
The number zero is an empty space, so for a parameterp_{k}
inO
to be a natural iterator (in a normal noninverse recursion) between commas, it must have a minimum value of p_{k}>1 before countdown. Or else it can be the last parameterp_{n}=1
inO = O(X,p_{n})
in which case it is dropped postcountdown, 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. 
#
Restriction on the range of iterators
OperatorialsO = O(R_{o},R_{p})
whereR_{o} = p_{*k},..,p_{0}
andR_{p} = p_{1},..,p_{n}
can reserve a single parameter constantp_{0}
or a range of constantsR_{o}
on the left, that must not be counted down.
For example bigE does this throughout, where parameterp_{0}
is the passive left operanda
, whose value is iterated over in operations (apart from addition) by the active right iteratorreceptorb
. The rules for bigE keep counting downb
asq_{1}:=p_{1}
in substitute inner expressionsO(p_{0},q_{1},p_{2})
, but neverp_{0}=a
who wait for lonely separators to drop and dissolve. 
#
Succession in
<<
parametric order
When in an expressionO
a parameter is counted down (in place), this creates a new expressionP
which is a parametric predecessor ofO
because it is parametrically smaller, writeP<<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. 
#
Definition of an algorithmic predecessor
The algorithmic predecessor of an expressionO
is a unique parametric predecessorQ
where the parameter counted down is the left or inner iteratorp_{s}
as defined in the contract for the inner iterator.
Within the context of a function definition, all predecessorsQ
are (theoretically) reducible to a natural number larger than zeroQ(Y) = 1... {#q>0} = q
When from an original expressionO
a rule ofO
has delivered the algorithmic predecessorQ
, the substitution ofQ
inO'
takes place to the left of the outer iteratorp_{r}
. Before substitution you can either reduceQ==q
to natural number or leaveQ
(for the time being) as a function expression. 
#
Discussion of recursive substitution
Operations of bigO are collections of evaluation rules, that transform an original (or nested original) expressionO
by reduction stepsO>O'...>...>N {'#i O'...#x}
finally to a natural number.
Every reduction step counts down the outer iterator inO_{k} = O'... {'#k}
and inserts a characteristic substituteQ_{k}
, which is the algorithmic predecessor of the expressionO_{k}
.
LetO(Xp_{s}Z)
be an original expressionO_{0}
wherep_{s}=m1
is the inner iterator. A recursive substitution rule ofO
then derivesQ_{0} = O(XmZ)
which replaces the outer receptor(s) inO_{1}
.
In the next reduction steps substituteQ_{k}
replaces the outer receptor(s) inO_{k1}
.
Each substitute or nested expressionQ
of course will suffer its own cascade of reduction steps. 
#
Discussion of numerical predecessors
When an expressionO = O(X)
is recursively reduced (partly) to a numerical expressionP
parametrically larger than its algorithmic predecessorQ {Q<<P}
we call the resulting expression a numerical predecessor ofO
.
The natural successor ofO(X) = x
is the numberx1
, and the natural predecessor ofx
isx
.
When such numerical predecessors still haveO(X)
as a subexpression, they cannot function as a substituteQ
in a recursive substitution rule forO
(except sometimes for initial cases), becauseO
'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

#
Contract for an inner iterator
A left or inner iteratorp_{s}
(peees
) is a parameter from an expressionO = O(R_{o},p_{1},..,p_{n})
which is counted down by a defining rule ofO
in order to create its algorithmic predecessorQ
. The only a priori requirement for substituteQ
is that it is parametrically smaller thanO
, so for an inner iteratorp_{s}=p_{i}
the rule can pick any unreserved index where p_{i}>1 or (on the last index)p_{n}=1
, following our general contract for iterators.
An example of bigE – inner iteratorb
is shown in ablue
square and outer iteratorc
inpink
E(a,b1,c1) = E(a,E(a,b,c1),c)
In this basic case of bigE, parameterb
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!) 
#
Contract for an outer iterator
The position of the right or outer iterator parameterp_{r}
(peear
) of an operatorialO = O(R_{o},p_{1},..,p_{n})
is selected by the rule which is applicable, depending on whether the value ofp_{r}
can be counted down. Except for all reserved parametersR_{o}
and the parameter at the first index r=1 ofO
's parameter array, the rule can pick anyp_{r}>1 {r>1}
or the parameterp_{n}=1
at the last indexn
, following the general contract of iterators.
For example inE(a,b)
the outer iterator isb
, laterE(a,b,c,..)
prefer the outer iteratorc
.
The ban on using the first parameter for outer iteration guarantees there is always an outer receptor parameter left to substitute the expressionQ
for, which safeguards the reducibility of bigE.
Maximized outer iteration –
Choose an early left parameter such as
p_{r}=p_{1}=b

Minimized outer iteration –
Persistently countdown final parameters
p_{r}=p_{n}=z

Maximized outer iteration –
Choose an early left parameter such as

#
Contract for outer receptors
The substitution in expressionO
of its algorithmic predecessorQ
, takes place (or starts) on the parameter index of the (rightmost) outer receptorp_{u}
(peeyu
), on the left of the outer iteratorp_{r}
.
The rules forO
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 indexp_{u}=p_{r}
all the way down to the leftmost unreserved index.
The outer receptors – noted in the singular asp_{u}
or indexed asp_{i} {1≤i≤u}
– need not come directly left of the outer iteratorp_{r}
, but there is good reason to do so. For if parameterp_{r}
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 parameterp_{r}:=p_{r}+p_{r}
(addition in exchange for a parameter is a senseless waste at this stage).
Maximized outer substitution –
Position outer receptors directly left
of outer iterator
p_{r}
.
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?

Maximized outer substitution –
Position outer receptors directly left
of outer iterator

#
Parameter dropping is separator iteration
When you iterate a final parameter down from1
and let drop that parameter postcountdown, this is parameter dropping, the initial form of dimension dropping. A parameter (containing a series of units1
separated by spaces) has dimension d=0, and a row (of parameters separated by single commas) has dimension d=1. By dropping a dimensiond
you iterate down the length of a higher dimensiond1
.
We measure the types of dimensions by separator commas too, sodropping
can properly be called separator iteration. 
#
Contract for inner receptors
This is an advanced topic, usually operatorial algorithms won't need it.
A primary inner receptoru_{1}
(yuwan
) is a parameter (of subexpressionQ_{0}
) positioned left of the inner iterator. This inner receptor is replaced by another algorithmic predecessor ofO
, usually of typeQ
(but not exactlyQ_{0}
sinceQ_{0}
has this newQ_{1}
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 expressionF = O
evaluated to an outer expressionF_{0} = O'
, wherein a single outer receptoru_{0}=p_{u}
substituted for an expressionF_{1} = Q_{0}
, wherein a single inner receptoru_{1}=q_{u}
was replaced by an expressionF_{2} = Q_{1}
(all in perfect harmony:^)
Such substitutions can be nested to an enumerable depth, which brings us the topic of vana. 
#
Vana substitution
We saw vana notation

#
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 AckermannConway in its first row,
because
Nn
uses the last parameterz
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
forQ
, 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 substitutey
for an enormous stack of nested substitutesQ'..
accumulated in bigE's default iteratorreceptorb
.
This shows that the outer iteratorp_{r}
should be positioned as far left as possible to create the Biggest numbers (so that the substitution of the outer receptor takes place at indexp_{r}=p_{1}
).

Example 1 – our function
Nn
replaces all parameters except the last,
but does become AckermannConway in its first row,
because
# 5.7. Whole row of waitors in bigY
yasya prabhâ prabhavato jagadandhakothi
kothishv ašeshavasudhâdi vibhûtibhinnam
tad brahma nishkalam anantam ašeshabhûtam
govindam âdipurusham 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. Superfactorial row bigU
The definition of front row bigU.
Under 2011 Construction
# 5.9. Algorithms over the first row
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."
under 2009 construction ~ OBSOLETE!
Algorithmic computer programme (a design in 24 hours
doc)
for the first row of bigI:

Let
I = I(p_{1},..,p_{n})
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. 
Case
C0
– length n=0 has as return value0

Case
C1
– length n=1 returns the value of parameterp_{1}

Case
C2
– length n=2 check if the second parameterp_{2}
has the value1
and if yes,
then let drop that second variablep_{2}:=0
and the trailing comma to double the value
in placeI'(p_{1}p_{1})
and take one more step, or just return the resulting numberp_{1}p_{1}
If not, then we haveI = I(a,b) {b≠1}
which can continue normally. 
Create a copy
J = J(q_{1},..,q_{n})
from the expressionI
This is not really necessary – only limited data needs to be passed – but it's instructional. 
Scan expression
J
from left to right, starting at the first parameter index1
until you find a parameter value q_{l}≠1. This will function as left or inner iterator. 
Fork
F0
– If you've found the inner iterator q_{l}>1 store its positionL {0<L<n1}
Then count it down by substitutingq_{l}' := q_{l}
on indexl
inJ'

Fork
F1
– Else you've come toJ
's right end, because all parameters areq_{i}=1
Then countdown the last parameterq_{n}':=0
and drop it, also drop trailing commas. 
F1
– Store the new last position as indexL:=n
of the inner iterator. 
F1
– Fetch the value ofq_{1}'
and substitute it at indexl
inJ'
by doingq_{l}':=q_{1}'

F1
– Store the last index as the position of the outer iteratorR:=n

The reduced expression
J'
now is the minimal algorithmic predecessor ofI
andI
is the minimal algorithmic successor ofJ'
(or thenext Big number
).
Countdown final parameterp_{R}':=0
and drop it fromI'
and also drop trailing commas. 
F0
– Scan the original expressionI
from left to right, starting at indexL1
until you find a parameter value p_{R}≠1. This will function as right or outer iterator. 
F0
ForkF2
– If you've now found a parameter p_{R}>1 store its positionR {L<R<n1}

F0
ForkF3
– Else you're atI
's right end, and all parameters {i>L} right of indexl
have the valuep_{i}=1
and so you fall back on p_{s}≠1 and store its position inR:=L

F0
EndF2 F3
– Decrease the outer iterator by substitutingp_{R}' := p_{R}
on indexR
inI'

End
F0 F1
– The index whereI'
must substitute forJ'
is always given byS:=R

Here
J'
is never a natural number, so substitution ofJ'
inI'
is postponed.
Store indexS
and a binary prepared stringI'
(or its mutation data) on top in the stack.
(with the provision your system manager tells you he still has enough computer memory!) 
Recursion –
The memory stack increases its length by one
Q':=Q1
You now take the next recursion step, call a new routine whereI'':=J'

Returns –
The
J'
the recursion returns here is a natural number, so the value
p_{S}' := J'
can now substitute for the parameterp_{S}'
at indexS
inI'

With a stack trace {Q>0} return the result
of the next bigI routine for
I'

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. 
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 sizeP
Given a current stack lengthQ
this can be estimated asQ*(p_{i}...n) {p_{i}#n} ~ P
but it would be better to keep count of the prepared string lengths in a global total.
If sizeP
is reached, recursively substitute the stringsJ'
inI'..
at positionsS..
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 forI:=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 metainformation
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 metainformation 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  
1A.  E  U/I  Y  
2E.  I  U/Y  
3I.  Y  
4U.  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 (whenZ=0
becauseX,=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.
bigΨ.III. Systems of Characters
Ψ.7. Extradimensionality
§7.0.1. Power tower boxing
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 nonfunctional (empty) separators.
Extradimensional 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 a1
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 extradimensional realm.
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 metabrackets
can be taken for granted, as we let the pattern P,_{T}::
= P,_{T}....
{,_{T}..#a #a}
for all subscripts T
continue.
a^^3
}P,_{T}:: {_{T}:S_{2},_{2;}.. _{#a}} = v\a1
P,_{T}:: {_{T}:S_{2},_{2;}..,_{2;}.. _{#a #2}} = v\a2
P,_{S3}:: {_{S3}:S_{2},_{2;}::} = v\aa = a^a^(a*3)
P,_{Sa}:: {_{Sa}:S_{d},_{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,a;}:: {_{Sa,a}:S_{a,a},_{a,a;}::} = v\*aa
P,_{Sa,..;}:: {_{Sa,.. #a}:S_{P'},_{P';}::} = v\*a^2 = a^a^a^3
P,_{Sa,..,..;}:: {_{Sa,..,.. #a #a}:S_{P'},_{P';}::} = a^a^a^4
P,_{S1,::;}:: {_{S1,:: ,..#a #a}:S_{P'},_{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.

Repetition by #a adds up to numbers
a

A single comma produces multiplication
a*b

Allowing countable commas equals powers
a^b

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 commatype 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 v_{0} = a
and build the first level dimension v_{1} = 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 v_{n}
of every new nest box can be calculated directly.
The dominant feature of this tetrative structure
is that repetitions of repetitions (powers) are nested.
The tetrative structure with its additive commas
is just the embryo in the extradimensional 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 depthseparator 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
(15401610)
Elaborating on our previous remarks,
we expect the deep countable character codes :c_{S}
to result in a^^a^^2
and by opening another depth cycle
:a_{S},_{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 sizen~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 nontyped ,
separator.
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;},^{.. }.. {,#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 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;}^{.. }.. ..
{T_{i}#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.
_{ } _{ } _{ } ^{ } under k_{i1}<k_{i}1 k_{i}<a m_{i}<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 nonterminated 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 extradimensional 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 hypercharacter 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 mixable_{2;}!)
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 hypercharacters
in our hypercharacter 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 depthtype
 :1111 Delimiter of depthtype 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 [R_{i}]^{.. }.:.
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 extradimensional 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 extradimensional enumerators of bigO
that reapply the previous array to count dimensions directly.
Ψ.8. Creating characters
§8.0.1. New rules