main →

## Construction of Big and Infinite Numbers

Author: Asamkhyeya dasa
Date: 9 april 2009
Motto: Invito Patre Numeri Verso

### # Short history of Big numbers

From the days of Egyptian hieroglyphs to Indian decimals to 16th century exponentiation our ability to express numbers in a concise manner has evolved: ``` 7555544444444333332222222111111 => 1048576 => 2^20```
We have defined a super-exponential function bigE.

E(a,b) = ab = a+b
E(a,1,c) = a [c>0]
E(a,b1,c1) = E(a,E(a,b,c1),c)

The Ackermann numbers are then expressed in bigE as `Ackermann(a) = E(a,a,a)`
The formula `C` for Conway's "chained→arrow→notation" are comparable to those of bigE with one row of parameters.

C(a,b,c) = E(a,b,c1)
C(a,..,y,1) = C(a,..,y)
C(a,..,x,1,z) = C(a,..,x)
C(a,..,x,y1,z1) = C(a,..,x,C(a,..,x,y,z1),z)
E(a,b,1,...) [1#k] = E(a,b,...) [b#k]
E(a,b,1,...,n1,..,z) [1#k] = E(a,b,...,n,..,z) [b#k1]
E(a,b1,c1,..,z) = E(a,E(a,b,c1,..,z),c,..,z)

Our objective is to create the fastest 'natural' algorithm for the construction of big numbers. The only hard criterion is reducibility.
Formula `C` as well as bigE have some setbacks which can still be improved upon – formula `F` for example does a pretty good job.

F(1,...,m1,n,..,z) [1#k] = F(m,...,n,..,z) [m#k1]
F(a1,t1,..,tm,z1) = F(v,...,z) [v#m1]  where v = F(a,t1,..,tm,z1)

This last function is definitely the fastest, because higher parameters (on the right) have most effect, and the substituted values `v` (which sort the biggest effect) nibble off ones on the lower (left) end.
In the present article on bigI and bigU notations, instead of substituting parameters, we go one dimension deeper and substitute the entities `1` that make up those numbers.

##### Literature:
• Wilhelm Ackermann "On Hilbert's construction of the real numbers", 1928
• John Conway & Richard Guy "The Book of Numbers", 1996
• Giga Gerard "Constructie van Grote getallen", 2009

### # Number entities

Introduce the concepts of an entity one `1` and a natural number `n` as a row of ones `1...` of length `n`.

1
1...[1#n] = n

The negative entity `- = -1` can be used in operator functions to create new sets of countable numbers such as fractions and algebraic complex numbers. We won't go into that here, this article is about big natural numbers.

Define a meta-notation for repetition.

Notation convention `ABC...D [B#n]` (`A`,`C` and `D` are optional and `B∉C`), explained:
The repetition rule between square meta-brackets `[B#n]` tells us to substitute `BC...` in the preceding expression with a row of `n` times the sequence `B`, putting sequence `C` in between (`B` being the first sequence `B` left of the ellipsis).
For example: ```b;...;1 [b#111] = b;b;b;1 = b;...1 [b;#111]```

Add two numbers by placing series of ones next to each other.

ab = 1...1... [1#a 1#b] = a+b

Introduce the concept of substitution of entities within natural numbers `n`.

n [1:a] = a...[a#n] = a*n

Entity `~` is a variable natural number variable that can change value each time it is used.
For `~` a certain set or bounds can be specified, mostly in the form `[~>n]`.
For example: ```1*......1 [*#~>0 1*...#k] = 1```

### # Parameters

Introduce the concept of a superator `;` that sits between the parameters of operator functions such as bigI.

X;0 = X; = X
a;1 = a [1:a] = a...[a#a] = a*a
a;11 = (a;1)...;1 [(a;1)#a] = a^6
a;111 = (a;11)...;11 [(a;11)#a] = a^42
a;b1 = (a;b)...;b [(a;b)#a]

Generally, to reduce an expression `X;z1` of bigI to natural number, we repeatedly countdown final parameters `z1` by one, and at each countdown substitute all entities `1` within the parameters of `X` with a joker `Jk`, which is based on the former largest number `X;z` and on the dimensionality of the expression.
We mention two variations for initial jokers `J` here, and apply the second variation in following formula.

1. Joker ``` J = J0``` can be derived from an expression `X;z` simply by removing all its superators, leaving only ones. Though this looks contrived, substitutions are possible without separate calculations (or inserting parentheses).
2. Joker ``` J = J0 = (X;z)``` is reduced to natural number before substitution (or remains in parentheses until later). This `J` is a 'one step smaller' number for expressions of a single parameter row.
a;b;1 = J...;J... [J#a J#b]  where J = a;b
a1;..;am;z1 = J...;...;z [J#ai J...#m]  where J = a1;..;am;z

Maximal general formula bigU

u = a1;t1;..;tm;z1 = v...;v...;...;z [v#a1 v#ti v...#m]  where v = a;t1;..;tm;z1
a1;t1;..;tm;1 = v...;v...;... [v#a1 v#ti v...#m]  where v = a;t1;..;tm;1
because  X;0 = X; = X
u = 1;...;b1;t1;..;tm;z1 [1#k1] = v;...;v...;v...;...;z [v#k1 v#b1 v#ti v...#m]
where v = 1;...;b1;b;t1;..;tm;z1 [1#k]
etc vk1 = b;...;t1;..;tm;z1 [b#k11]
because 0;...;b1;Y [0#k1] = 0;...;b1;b;Y [0#k]
X;0;...;b1;Y [0#k] = X;b1;b;...;Y [b#k]
so 1;...[1#k] = 1

Maximal example formula bigU

a;1 = v... [v#a v=a-;1] = a!
a1;b1 = v...;b [v#a1 v=a;b1]
a1;b;c1 = v...;v...;c [v#a1 v#b v=a;b;c1]

Maximal example expressions bigU

1;1 = 1
1;11 = v;1 [v=11;1] = 11;1 = 11 = 2
111;1 = vvv [v=11;1] = 111111 = 3! = 6
11;11 = 1111;1 = vvvv [v=111;1] = 4! = 24
111;11 = vvv;1 [v=11;11] = (3*(2*2!)!)! = 72! ~ 6E103 ~ 43 bytes
1111;11 = vvvv;1 [v=111;11] = (4*(3*(2*2!)!)!)! ~ 5E91 Tb
1;111 = v;11 [v=111;11] = U(72!,2)

### # Rows

We describe four variations of joker substitution in bigI here, and apply the second.
Variations III. and IV. work with direct substitution – replacing entities with an unresolved subsentence `Jk`.

1. Jokers `Jk` can be reduced to natural number before substitution, and then simply added.
2. Jokers `Jk` are reduced to natural number (in theory), followed by superators `;...[;#k]` of length `k` in between.
3. Jokers `Jk` may remain an array of parameters `J`, followed by superators `;...[;#k]` of length `k` in between.
4. Same as variation III. with an opening parenthesis preceding jokers `(Jk` and a virtual closing parenthesis at the end:`)`

Enter the second dimension of bigI's parameter array and expand previous parameter rows by replacing entities `1` in previous rows subsequently by `J1`, which represents a row of `J` parameters `J`.

a;;1 = J1;...[J1#a]  where J1 = a;...[a#a]
a;;z1 = J1;...;;z [J1#a]  where J1 = J;...[J#J] and J = a;;z

Superator operations are resolved from right to left. We'll evaluate expressions by rule of maximal precedence, where right operands separately address each entity in every left operand (not in parentheses) up to the start.
Follows the formula for bigI up to the second dimension, separately substituting every parameter.

a;b;;z1 = J1;...;;z [J1#ab]  where J = a;b;;z
a1;..;ak;;b1;..;bm;z1 = J1;...;;J...;...;z [J1#a1..ak J#bi J...#m]
a1,1;..;a1,k1;;..;;ar1,1;..;ar1,m;z1 =
J1;...;;...;;J...;...;z [J1#aj,1..aj,kj J1;...#r J#ar1,i J...#m]

Maximal general formula bigU

a1;X => v = V(a1;X) = a;X as usual
V1 = V0;...[V0#V0]  where V0 = v
a1;t1,1;..;t1,k1;;..;;tr1,1;..;tr1,kr1;z1 = V1...;V1...;...;;...;;V0...;...;z
[V1#a1 V1#tj,1..tj,kj V1...#kj V1...;...#r V0#tr1,i V0...#kr1]

Maximal example formula bigU

a1;;1 = V1...[V1#a1]  where v = a;;1
a1;;z1 = V1...;;z [V1#a1]  where v = a;;z1
a1;b;;z1 = V1...;V1...;;z [V1#a1 V1#b]  where v = a;b;;z1
a1;t1,1;..;t1,k;;t11,1;..;t11,m;z1 =
V1...;V1...;...;;V0...;...;z [V1#a1 V1#t1,i V1...#k V0#t11,i V0...#m]

### # Dimensions

We formulate two variations of joker array construction by direct substitution here, and use the first for bigI.
(Natural number substitution of previous jokers replaces `:=` by `=` in the formula below, but that would slow down the algorithm.)

1. Jokers `Jn` are `n`-dimensional arrays, where all inner dimension lengths are equal to `J`, creating a giant dimension box.
``` Jm1 := Jm;...... [;#m1 Jm#J]```
2. Jokers `Jn` are `n`-dimensional arrays, where dimension lengths are repeated by the dimension's value. Their shape gets elongated in the higher dimensions — like a very long brush stroke.
``` Jm1 := Jm;...... [;#m1 Jm#Jm]```

As an example we enter the third dimension of bigI and expand previous parameters by replacing every entity `1` subsequently by `J11`, which represents a square of `J×J` parameters `J`.

a;;;1 = J11;;...[J11#a]  where J11 = J1;;...[J1#a] with J1 := a;...[a#a]
a;;;z1 = J11;;...;;;z [J11#a]  where J11 = J1;;...[J1#J] with J1 := J;...[J#J]

Choosing substitution variation II. or III. above, we use jokers `Jk` to substitute entities `1` and superators `;...[;#k]` of length `k` are put in between. The principle applied here is to replace the virtual superators `;...[;#0]` of length `0` in between entities. Then also every superator `;...[;#m 0<m<k]` in between parameters, should be replaced by a superator of the appropriate maximal length `k`.
Abiding by the principle of substitution variation I. we could have kept the existing superators as is.

a;b;;;z1 = J11;;...;;;z [J11#ab]

Evaluation definition – Move right to left, count down parameter `z1` and subdivide expression bigI into sections `Si`, where `Sk` in `X;...Sk;...Y;z ``[;#m ;#k1 m>k1]` is the section between the expression's rightmost superator `;...[;#k1]` on the right and the rightmost superator `;...[;#m m>k1]` (if any) on the left. Then for all subscripts `Sx in X [x>k]` and for all subscripts `Sy in Y [y<k]`.
Within section `Sk` use jokers `Jk` (as defined above for dimensions and below for types) to substitute entities `1` and (optionally) use superators `;...[;#k]` to append and to substitute existing posterior superators `;...[;#m m<k]`.
This defines the evaluation of expressions bigI in all dimensions and for all types.

Maximal general formula bigU

Evaluation definition – Move right to left, count down parameter `z1` and subdivide expression bigU into sections `Si`, where `Sk` in `X;...Sk;...Y;z ``[;#m ;#k1 m>k1]` is the section between the expression's rightmost superator `;...[;#k1]` on the right and the rightmost superator `;...[;#m m>k1]` (if any) on the left. Then for all subscripts ```Sx in X [x>k]``` and for all subscripts ```Sy in Y [y<k]```.
Within section `Sk` use vana `Vk` (as defined below for 0-type bigU dimensions and separately for n-types) to substitute entities `1`.

NOTE: The bigI evaluation rule to append superators and substitute existing posterior superators feels a bit contrived, we won't use it here. The advantage of introducing superators inbetween would be small compared to the number of such superators in the vana.

Trivial cases: `X;...[;#n] = X` and single ones: ```;...1;......1 [;#p ;#~>0 1;...#k] = 1```
This defines the evaluation of expressions bigU in all dimensions and for all types.

Substitution definition – for bigU expressions `u = a;X`
Dimensional vana are constructed with natural number substitution (instead of the direct substitution we used before, when previous Joker dimensions where directly inserted as character sequences).

Initial vana:
```    u = 11X => v = 1X    u = 1;......;b1;X [;#~>0 1;...#k1] => v = 1;......;b1;b;X [;#~>0 1;...#k]```
Next vana:
```    Vm1 = Vm;...... [;#m1 Vm#Vm]  and V0 = v ```

Maximal example formula bigU

V11 = V1;;...[V1#V1]  with V1 = v;...[v#v]
a1;;;1 = V11...[V11#a1]  where v = a;;;1
a1;;;z1 = V11...;;;z [V11#a1]  where v = a;;;z1
a1;b;;;z1 = V11...;V11...;;;z [V11#a1 V11#b]  where v = a;b;;;z1

### # Types

Preceding superators `;...[;#p]` create extradimensional bigI functions of type `p`, which are constructed similarly to the typeless bigI above.

;a = Ja  where J = a
;a;1 = ;a [1:J] = ;J...[J#a]  where J = ;a
;a;b1 = ;J...;b [J#a]  where J = ;a;b
;a1;..;am;z1 = ;J...;...;z [J#ai J...#m]  where J = ;a1;..;am;z
;a;;z1 = ;J1;...;;z [J1#a]  where J1 = ;J;...[J#J] and J = ;a;;z

Apply the following joker construction principles to substitution variations I. or II. or IV. (we apply II.).
For variation III. to be possible without separate calculations (or inserting parentheses) the substitution jokers `Jn` must remain without prefixed type-superators.

1. A bigI expression ``` ;...1X;z1 [;#p]``` has an initial joker ``` J = J0 = ;...1X;z [;#p]```
2. and next jokers ``` Jn = ;...Jm1 [;#p] with each Jm1 := Jm;...... [;#m1 Jm#J m<n]```

These jokers are to be substituted into bigI expressions, as shown in type-reduction and the general two parameter case.

;...a [;#p1] = ;...Ja [;#p]  where J = ;...a [;#p]
;...a;...z1 [;#p ;#m1] = ;...Jm;......;...z [;#p ;#m Jm#a ;#m1]

The evaluation definition in the previous chapter explains the rules to reduce all typed bigI expressions to natural number.

Maximal general formula bigU

;...a1 [;#p1] = ;...Va1 [;#p Va1#a1]  where v = ;...a [;#p1]

Substitution definition – for bigU expressions ```u = ;...a;X [;#p1]```
Initial vana:
```    u = ;...11X [;#p1] => v = V0 = ;...1X [;#p1]    u = ;...1;......;b1;X [;#p1 ;#~>0 1;...#k1] =>    v = ;...1;......;b1;b;X [;#p1 ;#~>0 1;...#k]```
Next vana:
```    Vm1 = ;...Vm;...... [;#p ;#Vm Vm#Vm]```

Maximal example formula bigU

;a = Va [Va#a]  where v = ;a-
;a1;t1;..;tm;z1 = v...;v...;...;z [v#a1 v#ti v...#m]  where v = ;a;t1;..;tm;z1
;a1;;z1 = ;V1...;;z [V1#a1]  where V1 = v;......[;#v v#v] and v = ;a;;z1
;...a1;...z1 [;#p1 ;#m1] = ;...Vm...;...z [;#p1 Vm#a1 ;#m1]
where Vk1 = ;...Vk;...... [;#p ;#Vk Vk#Vk]  and V0 = ;...a;...z1 [;#p1 ;#m1]

### # Characters

The bigI and bigU numbers in the previous chapters are written using only two characters. The algorithms we've used to reduce them to single character `1...` format are about the fastest we can get given certain esthetic constraints such as algorithmic simplicity. The whole digit range of binary number notation is covered, introducing the concepts of parameter rows and dimensions and types to illustrate every possible ordering of the number character `1` and its superator `;`

To move one step further and "jump out of the box, into the ocean", we need to introduce a third mathematical character. This new character would typically redefine the strength of the previous two characters, depending on their mutual position in the sequence, and thereby increase the speed of the total algorithm. And similarly to `;...` (dimensions and types), multiples of this new character (again depending on position) would increase inherent character strength dramatically.

It would take a lot of effort on a mathematician's part to exploit all the possibilities an extra character gives maximally. In combination with previous characters – how many fundamentally different character sequences are there? What is their natural order? How do we define these sequences to produce the biggest numbers? How do we keep it simple and continue in a certain style – the natural expansion of bigI or bigU (or any other two character algorithm)? Is such a basic style systematically definable or is it a question of trial and error?

After 3 characters comes a 4th. Of course any number of extra characters can be introduced to define faster algorithms to create bigger countable numbers. And every next character will in principle count (or boost the length of) series of previous characters a magnitude faster than previous characters can (applied to themselves).
But you can't have a character to express the length of your list of characters directly – such a character counter cannot be designated with a character from the same character list – logically it would have to qualify as a meta-character. From then on you're talking in a higher order language. Next thing you're introducing meta-characters to count previous meta-characters, creating levels of meta-characters which you can count with a meta-level counter, for which you need... a meta-meta character. This sequence of meta-meta-metas never stops, and the order of your language is lost in oblivion.

### # Maximum Cycli

Imagine a meta-function of bigX which tells us what the biggest number is we can express in bigX (eg. bigU) with a given number of places and characters. Such a maximum function may remind you of the busy beaver, which is a Turing machine that starts on an empty tape, runs as long as possible, and eventually halts. The maximal number of characters a Turing machine in a certain `n`-state can theoretically write on tape is called its busy beaver number (a function of `n`). Those numbers have been proved to be non-computable.

The biggest number expressible in bigU with `2` mathematical characters on `a+3` places is `;...111 [;#a]`, this is proven up to extradimensional vana in next chapter's box in case `u5` (note that wana require a `1` digit less).
Following this example we can define what the maximum numbers expressible in bigU with arbitrary numbers of characters look like, even though we still haven't got a clue what the new characters do and what the best algorithms are to reduce such expressions (and whether `m`-character algorithms can be proved to be systematically definable).
It feels a constructive step to state beforehand, that in a bigU notation deploying `m` characters fully and the latest character number `m` written as `μm`, the maximum number expressible on `a111` places is ```μm...111 [μm#a]```.

You might like to drop the "number of characters" parameter and make your max-functions solely dependent on the "number of places", simply because you like single parameter functions. There's a binary workaround for this. We can express our mathematical alphabet in binary bits, similar to a bit-expression in a computer, where `m=2^7` ASCII characters can be expressed in `n=7` bits.
Suppose the successive versions of bigU always work with binary alphabets and you can employ any number of mathematical characters you like, then the number of characters `m` we'd best use to create the biggest numbers are powers of two `m=2^n` (else we have to leave character bits undefined). Now, because there's always a trade-off between character bits and places, less places means there is not much room for alphabets that write advanced characters with a lot of bits (if you want big numbers).

 n=0 m=1 111 maximum number for a<4 n=1 m=2 (000)0111 max for 311 2^(n-1)

Because of such binary trade-offs, a maximum function of bigX can be a function solely of the available number of places.

When big`X` enters a new cycle, it is succeeded by a function big`XX` whose power is comparable to the maximum functions described above. After the first parameter every big`XX` will get a second, counting the first, etc. Parameters, rows, dimensions, types and optionally characters beyond two – if the corresponding algorithms can be systematically defined for every next character – all these constructs are reducible by the same algorithmic model that applies to the original function big`X`.
When this next cycle is completed a new maximum function big`XXX` of big`XX` follows the same path, etc. Of course, the large number of characters implied by a character counting cycle are not required to describe the cycling model itself.

Further on we start to count the number of `X`'s in big`X...[X#a]`, as the primary cycles for a cycle function of bigX, a meta-meta function so to speak, which again is reducible by the same algorithmic blueprint we originally defined for big`X`.
Are the functions counted by `X`'s the first meta-level functions and cycli the second (meta-meta), many more meta-level functions will follow. And irrespective if all those different levels can be represented as parameters in a comprehensive single bigX-style meta-level counting function, all levels can at least be counted, so the numbers they create will be bigger than ever.

Similar cycli lie at the heart of what the introduction of a new character means (in fact we cycled from one parameter to multiple dimensions before). Only if a 3-character cycle mechanism is exhausted fully, a 4-th character cycle comes into question. And only if (the construction of algorithms for cycling) every next character is defined, there can be meta-cycling over the characters as a whole. And after that meta-meta-cycling and the counting of metas, it never stops...

### # Principles

For an algorithm there are principles and disciples.
Principles are the broad concepts that form algorithms, and disciples are number expressions that can be reduced by those algorithms. Because anything in nature can be represented fully in a binary series and eventually translated to a row of ones, everyone is a disciple.

More and deeper principles allow us to create bigger numbers. The way to invent principles is just to start and see what happens. How about the principle that everything we encounter twice is countable? It's a question of recognizing the one and the two.

• First someone wrote a row of ones to signify a number. Second two rows of ones for two numbers. Numbers could be counted.
• Somebody came up with the idea to have one number repeated by another (multiplication `×`). Somebody else repeated the repetitions themselves (exponentiation `^`). Later it appeared those levels of repetition are countable (super-exponentiation `*...`).
• Ackermann made the first rudimentary jump from a super-exponential function `E(a,b,c)`, where the 3d parameter counts the number of operators. Inspired by this Conway introduced a function where the parameter row could go on indefinitely. Then some big number enthusiasts realised the length of parameter rows is countable inside a multidimensional parameter array.
• So I invented the countable superator `;` to separate dimensions and took it as just a 2nd character after which come many more... But first I had to fill my super-binary notation to the brim with extradimensional types that expand (count) dimensions (superators).

There are four principles at work in the definition of algorithms that write big numbers. Except for a further elaboration on the 4th big principle – reminiscent of Rinzai's guest sees guest – we've met them before.

1. Introduction of the Host – an origination where ...
1. an entity enters the room ... be it `1`, `-` (minus one) or `ω` (initial infinity).
2. a superator divides and rules the room ... be it the zero-character `;` or a character counter or meta-cycle counter
2. Expansion of the Host – construct an expression ...
1. without superators ... from a number of entities
2. with single superators ... to a row of parameters
3. with countable superators ... to a multidimensional array
4. with function type superators ... to an extradimensional array
5. with extra superator characters ... to cycli of functions
6. with superator character counting ... to meta-cycli, etc.
3. Introduction of the Guest – reduce an expression by ...
1. dropping a parameter (compare Dedekind's 1888 general definition of a primitive recursive function) by counting off a superator or higher construct 'on the edges' of an expression. This happens in a bigX Host when its final parameter `z` is reduced from `1`.
2. substituting one or more or all possible parameters or their entities inside the Host by an initial vana `v`, which is a Guest expression derived directly from (and smaller than) the Host, by counting down a parameter so that reducibility is assured. "Guest invitation" in bigU is maximal, because its initial vana counts down the most insignificant Host parameter by `1`.
To evaluate a multi-parameter Guest it must itself become Host to another Guest – a new invitation at every reduction step!
4. Expansion of the Guest – construct substitution values by ...
1. application of constructs from a lower expansion of the Host to prefabricate the vana. Various vana `Vm` can be made multidimensional or extradimensional, etc. so long as their substitution position in the Host expression preserves reducibility.
We've tried to achieve maximal vana expression for bigU up to types in earlier boxes.
2. alternative rules (unlike those used in the Host), to boost vana performance. By inflating the number and type of vana construction steps (up to a certain limit imposed by the Host expression), we can work further to maximize the Guest.
The following box shows just such an effort to "entertain Guests" through wana nesting.

My experimental wana nesting add-ons are not as fast as character introduction by maximum cycli (see previous chapter), and perhaps overly complicated (see example box).

Wana nesting examples in bigU

u1 = a1;z1 = v...;z [v#a1] & v = w...;z [w#a1] & w = a;z1
u2 = 1;b1;z1 = v;v...;z [v#b1] & v = w1;b;z1 & w1 = w11;b;z1 & w11 = b1;b;z1
u3 = a1;;z1 = V1...;;z [V1#a1] & V1 = v;...[v#v] & v = w0
& wn = wn1...;;z [wn1#a1] & wx = a;;z1 => wana W1 = W(x)
u4 = 1;;;b1;;z1 = V11;;;V1...;;z [V1#b1] & V11 = V1;;...[V1#V1]
& V1 = v;...[v#v] & v = w0 & wn = wn1;;;b;;z1 & wx = b1;;;b;;z1
& x = b1;;;b;;z1 => wana W1 = W(W(1)) = W(1,1)
u5 = ;;11 = ;V11V11 & V11 = ;V1;......[;#V1 V1#V1] & V1 = ;V0;......[;#V0 V0#V0]
& V0 = v & v = ;;1 = 1 = V1 = V11 => u5 = ;11 = 11
| V0 = w0 & wn = ;wn1wn1 & wx = ;;1 => wana W1 = W(x) > W(y,Y)
u6 = ;;;a1 = ;;Va1...[Va1#a1] & Vm1 = ;;Vm;...... [;#Vm Vm#Vm]
& V0 = v = w0 & wn = ;;wn1...[wn1#a1] & wx = ;;;a
& x = ;;wx1,x11...[wx1,x11#a1] & wt1,t11 = ;;wt11,t11...[wt11,t11#a1]
& ( t1 = wx => t1 = 1 & t11 = t111 ) => wana W1 = W(x1,x11)
Conjecture U(T) & stop wx => wana Wn < W(T)

### # Infinities

One cannot count up to infinity, but Georg Cantor in 1874 invented two different types of infinity: a countable infinity (counting all natural numbers), which is bigger than any countable number, and an uncountable infinity (counting all real numbers), which is bigger than any number that counts "deeper than countable" numbers.
Cantor couldn't find the connection between these two infinities by counting upwards with his countable infinity `ω` (omega).

So far all the numbers we've created with our algorithms for big numbers and `1` are countable and smaller than infinity. Only by postulating a first uncountable number `ω` and using it as an entity to seed a super-exponential function bigE or a super-factorial function bigU, we can count further into the infinite realm, the same old way Cantor progressed with his ordinal numbers.

E(1,ω) = ω
E(ω,1) = ω+1
E(ω,11,1) = ω+ω
E(ω,11,11) = ω^2
U(ω,1) = ω! (factorial omega)
E(ω,11,111) = ω^ω
U(ω,11) (super-2-factorial omega)
E(ω,11,1111) = ε0

Though Cantor showed his famous diagonal argument in radix `r=2`, a special case of `E(r,ω,11)`, the positioning of numbers inbetween earlier ones can be much more intricate than Cantor suggested, if we'd exploit the whole parameter range of a big number algorithm.
Deeper and down the reals, the cardinality of the continuum must be an order higher than that of the discrete infinite numbers we create by means of the uncountable entity `ω` (and countable entities such as `1` and `-`).

The only way to make Cantor's uncountable infinity countable is by postulating a higher type of infinity – an ordering of heavens so to speak.
Starting from the countable finity ``` 1=ω0``` and the countable infinity ``` ω=ω1```, the next-countable infinity `ω11` can be as big as the set `ℜ` of ω-deep numbers created by bigE or by any big`X...` (inverse) iteration of any number of finite or countably infinite entities.
These and the unavoidable next 'Cantor-uncountable' `ωn` infinities we can count with infinite number functions of general type bigXΩ and induction. For example:

XΩ() = 1
XΩ(1) = ω1 = ω
XΩ(11) = ω11
XΩ(a) = ωa
EΩ(1,1) = EΩ(EΩ(1)) = EΩ(ω) = ωω
EΩ(a,1) = EΩ(EΩ(a))
IΩ(a,b1) = IΩ(IΩ(a,b),b)
UΩ(a1,b1) = UΩ(UΩ(a,b1),b)
UΩ(a1,t1,..,tm,z1) = UΩ(v...,v...,...,z) [v#a1 v#ti v...#m]
where v = UΩ(a,t1,..,tm,z1)

This last expression models the first row of parameters of bigUΩ after bigU. We can continue that model with the same algorithms for dimensions, types and cycli as for bigU, reducing the bigUΩ parameter array to a natural number `n` as usual and finally to an infinity `ωn`, in an effort to write the UΩ travel-guide for the realm of meta-countable infinities.
When we wake up the next morning the U-subscript `Ω` itself has started franchising the business model of bigU:

UΩ(0)(X) = U(X)
UΩ(1)(X) = UΩ(X)
UΩ(11)() = UΩ(1)(1) = ω
UΩ(11)(1) = UΩ(11)(1)1
UΩ(a1)() = UΩ(a)(1)
UΩ(a)(b) = UΩ(a)(1)b

As the following parameters of the U-subscripted function `Ω` pass through dimensions and cycles, a new infinite number can be postulated that lies beyond its reach. This next order of infinity has its own generator function, which means in effect that `Ω` will be `Ω`-subscripted itself. Counting `Ω`-subscript depths for higher order infinity generator functions has its appeal, but don't think bigX-franchising will end with an infinite number that lies beyond the reach of `Ω`-subscription. That's just a next step "out of the box and into the ocean".

But maybe, if God created `1` from the void and Cantor did it for natural numbers, we are now in a position to propose an infinite number beyond compare – unreachable by any algorithm of any number generator `X` and infinity generator `Ω`. It lies wholly beyond the methods of induction on ones and omegas and of such induction on models, and is therefore beyond compare.
Perhaps you'd like to call that number `ψ` (psi), I don't mind about names.
After `Ψ(0)=0`, `Ψ(1)=ψ` could be the first zero reincarnate, and `Ψ(ψ)=ψψ` a reincarnation of reincarnations – the "biggest number" of our time, because I halted. But what if the finest mathematicians of all time would reincarnate in a big bang bubble with infinite resources and the sole purpose of inventing big numbers, when would they halt? Call that number St. Peter's Subway.