# # Bigger

The search for Big numbers only stops at infinity, but long before the people reach this limit all resources will be exhausted. However, when we call a number “infinite” a Bigger counting game begins…

### §2.0.1. What is omega?

Cantor's omega `ω` is just a name for unlimited counting. When a count of units `1..` stops, we have defined a natural number. Without halt, the endless series of ones this finally would produce is called `ω` in advance.

```n = 1.. :n = 1{n}  (natural numbers)
ω = 1.. = 1{ω}  (infinity has no bound)```

A set of possible numbers is called infinite, when its construction is never finished. This is not a real problem, because every set should have a mathematical plan of construction that determines its final projected size.
For the set of natural numbers, as we count numbers from `1` to `n`, the size label tends to coincide with its largest number. Now in theory we can take all the elements of a set created by natural counting, and define the total size or cardinal of this set to match the number `ω`.

Georg Cantor's leap of faith that an endless enumeration of `1..` halts right at (or if no count `0` is initial element: just before) the number `ω`, has its parallel in the axiom of infinity of set theory.
The axiom of infinity is self-proclaimed, “By union with my set I can grow endlessly, therefore infinity exists.” Cantor used the cardinal `ω` to enumerate those sets, where union after union add up to an infinite number of elements. This smallest infinite set exists far `>>` on top of all finite sets.

`ω >> n  (infinity passes any finite number)`

No big natural number `n` comes closer to `ω` than a smaller, such as `0`, because the distance stays infinite. Measured by `nω`, up to omega all natural numbers are equally small.
As soon as we have an infinite number, by Cantor's rule we can count further `ωn` on the right, which adds up as usual. But left finite numbers count as `0`, still at infinite distance from `ω`.
Addition at infinity is not commutative. We notate ordinal evaluations by `o=` with a small o attached on the side where numbers are lost against infinity.

```nω o= ω  (add before infinity)
ωn > ω  (add after infinity)```

To leap from a finite number set to the infinite `ω`, is a similar act of faith as going from unit `1` to pair `11` in the natural world. How can two ones be compared, when in the quantum world no thing is copied for free? By wishful thinking we count objects together, and likewise it is our mystery mind that foresees the infinite. Not so extraordinary after all?

Natural numbers are constructed by the successor function `1(n)` `= n1`, and their cardinal (total number of elements) is our key `ω` to step through the looking glass and into the realm of infinity. There we can walk further to successors of `ω` and over bigger counting functions.
Late 19th century Georg Cantor found that the set of real numbers cannot be indexed by (paired to, put in one-to-one correspondence with) the natural numbers. He imagined having found the key to the real infinity, which later turned round to become the next inaccessible name.
After two names `1,ω` should follow a third, so higher infinities exist. When naming can be indexed, Bigger indexing functions produce ever more names. Infinity becomes a virtual house of mirrors.

An alternative, less transcendental explanation is that by `ω` counting is closed.
Any Bigger number than we can ever construct in theory by natural number functions will do, in case our algorithm depends on physical resources for example. This arbitrary definition of set closure can deploy its natural omega as function input too, to output ever higher natural cardinals.
The recursions in coming chapters would be developed much the same, working with natural limit numbers as with `ω` based infinities.

Let the identity `0(x) = x` be our initial function, and start with an empty number set. We can name a new number `1` that is different from before.

`1 > 0()`

Continue from the last to create new numbers by name. We can pretend not to know what `2` is, just call it by `>` to be the next different from `1` itself. Because the identity function `0` is itself void and zero, these number names come up in rising order.

```2 > 0(1)
3 > 0(2)
n1 > 0(n)```

This list alone defines our numbers here, there's no other function. Because there is no other info to relate these names, the next relation works the same as the successor axiom `1(n) ≠ n` that constructs the set of natural numbers. Without arithmetic, without counting, just pointing at new signs like a child.

From the natural number names we define omega `ω` to be an even Bigger name.
Let the name index `í` increase from `1` on the left, to the total `n` on the right.

```0 << .1{í}<..n1 :n
O().< 0(í).. << ω```

When there is no bound to the repetition we put the number name `ω` on top.
After `>` nexts comes a bigger `>>` Next. Infinity follows from self-reflection taking a second perspective. Hard to do with only one eye!

### §2.0.2. Count from omega

Once we have given infinite counting the name omega and placed this `ω` as a meta-stop on the number line, we can count onward.
The existence of some number sets that escape enumeration by such infinite counting, was proof for Cantor that higher infinities exist. Then it would be appropriate to count further from `ω` and cover more numbers.
Right from `ω` lies the infinitely big wide open – Cantor's paradise of ordinal numbers.

Cantor found that the set of real numbers has a higher infinite number of elements than the set `ω` of natural numbers. Its true size is a matter of debate, settled by convention, but the real cardinal number is projected to exist far beyond `ω`, regardless how we define all the reals.

We quickly move past the initial omega, by right adding numbers `n` to `ω` repetitively.

```ω < ωn < ωn1 < ωω  {n>0}
< ωωn < ωωω < ω*p  {p>3}```

Considering the rate at which various functions grow, the following comparisons can be made: for numbers `m,n` not too small, and `w↑ω` a large natural number approaching infinity.

```w**n < m**w < w***n < m***w
< m*{w}n  (superpowers)```

Does this bigO ordering of function growth limits hold for truly infinite numbers too?
In ordinal arithmetic `n*ω` `o= ω` for `{n>1}` is smaller than `ω*n` `= ω{n}` for example.

To transcend finite sequences we have to break them somewhere, to jump to omega. Performing a series of such `ω` jumps this adds up to a higher ordinal. But if infinity is reached at the end of a sequence, it seems the finite was just broken once!
The path our best athlete Cantor chooses through number space, determines how many `ω` hurdles he has to take before the finish. Cantor is a fearless jumper, each infinity he encounters is of omega width, but he'd rather save them up to the end, and transcend the infinitely wide abyss just once. Would you accuse him of foul play?

```3*ω1 = 111..111 :ω o= ω3  <
ω1*3 = ω1ω1ω1 o= ωωω1  (ordinal)```

In the latter expression there are `3` infinite jumps, but in the former Cantor keeps counting.
The usual ordinal notion disregards the rate at which functions naturally grow. In the ordinal system the power `ω^n` is larger than `m^ω` (and larger even than `m*{ω}n` superpowers).

```m^ω {m<<ω} = 2^(lôg(m,2,1)*ω) o= 2^ω
= 2*.2*.. :ω- o= 2*.. :ω- = 2^ω-
o== c*c^ω-{x} where c^ω-{x} = ω
o= ω  (ordinal return)```

We rely on transfinite subtraction: the assumption `1{ω}-{ω}` `o= n` that infinitely decrementing `ω` returns to the natural numbers. But we can only drop `2*` against `ω`, not against smaller numbers, so there the ordinal return stopped.

```m^ω1 = m^ω*m o= ω*m  <
ω1^n = ω1*..1 :n o=  ω^n+1  (ordinal)```

This is madness, Cantor valued the reals at `2^ω`, even he didn't jump to such conclusions.
But when we take Evel Knievel as our set theorist, infinite sequences like `2*{ω}3` are run over by bold ordinal logic! Note that infinite superpowers `*{ω1} ≡ ^{ω}` are equal.

```m*{ω}1 = m*{ω-}1 == m
2*{ω}2 = 2*{ω-}2 == 4
2*{ω}4 = 2*{ω-}2*{ω}3 = 2*{ω-}2*{ω-}4
== 2..*{ì}2.*4 :ω- o= ω
(where `ì` increases from `1`  resolved `*` on the right to `ω-` stars on the left)```

Oops! That doesn't help. But the solution is easier than expected.
The same argumentation that got `m^ω` `o= ω` above, can be applied to `m^^ω` `o= ω` and inductively to any superpower `m^{n}ω` `o= ω` so that `m^{ω}ω` `o= ω` by transfinite induction.
For non-trivial cases `1<n<<ω` where `m^{ω}n` produces an infinite sequence, we should have `m^{ω}n` `o= ω` too, because there is no smaller infinity than `ω`.

The unorthodox consequences this has are discussed in the section on omega walks, where we reach the conclusion that Cantor's plan for the ordinals is pretty useless. For the size of infinite number arrays it's better to rely on the same bigO function limits as for natural numbers.
To prevent historical ambiguities, here we continue to speed add `ω` by expanding arrays in Btrix, where the primer atom `a=ω` spills over to big entry `b` and from there serial infinities are uploaded to indexes in ever higher array structures.
Both ordinal and bigO comparisons will match the outcome of omega Btrix, and she catches up with Bird's arrays when both are nested to infinite depth. All mathematical gods will be pleased.

For slower counting, stepwise expansion of the infinite, follow our ordinal model `O` here in *1 below, or find out how to implement `ω` as a number base for Box bytes in the next section.

Take as identity the function `O(x) ≥ x` (identity or equality `=` is expressed here, because the greater part of `≥` is superfluous). Put next ordinal numbers in `>` order with the `O(X)` naming function, expressing natural addition `m` and repetition `n` past omega.

```ω >> O(m) ≥ m
ω1 > O(1,1) ≥ ω
ω2 > O(2,1) ≥ ω1
ωm1 > O(m1,1) ≥ ωm```
`ωω >> O(O(m),1) ≥ O(m,1)`

The sign `>` names the next ordinal number on the left, the sign `<` places the next number on its right. We are just giving names here to Bigger numbers than we can grasp, but our name book `O` begins to look like an array function for ordinal arithmetic.

```ωω1 > O(1,2) ≥ ωω
ωωm > O(m,2) ≥ ωωm-
ω..1 :n > O(1,n) ≥ ω.. :n
ω..m :n > O(m,n) ≥ ω..m-```
`ω*ω >> O(m,n)`

The 1st parameter of `O` is reserved for addition, and the 2nd for multiplication. In the 3d entry, initialized as before, we find (to our surprise!) we have to multiply again to catch all names.

```O(1,1,1) ≥ ω^2
O(2,1,1) ≥ ω^2+1
O(1,2,1) ≥ ω^2+ω = ω*ω1
O(1,1,2) ≥ ω^2+ω^2 = ω*ω*2```
`ω*ω*ω >> O(m,n1,n2)`

Multiplication is to be continued on the row. Every next entry `ni` functions as a larger factor of omega. Further right (at the `nω` index) we will introduce infinite structures, inserting separators corresponding to higher functions (from powers `ω^ω` onwards).

On the left you could introduce an infinitesimal dot in `O(N.P)` to express infinite fractions with a negative `N` array, in addition to the whole entries of our positive `P` array.
An `ω` infinite number of `O(1.)` `= 1/ω` infinitesimals counts up to `O(.1)` `= 1` in this system. The 2nd infinitesimal `O(1,1.)` `= 1/ω/ω` , the row `O(1,[1]1.)` `= 1/ω^ω` , the plane `O(1,[2]1.)` `= 1/ω^ω^2` , dimensions `O(1,[1,1]1.)` `= 1/ω^^3` , etcetera…
All positions left of the infinitesimal point carry fractions of their omega equivalents, and are thus added to the grand total. This seems not so useful at first sight, because normal fractions are missing. But you can divide two of these mirror infinite arrays `O(N1.P1)/O(N2.P2)` to cover the class of infinite rational numbers.

### §2.0.3. Byte box omega

We construct a radix array function `Box(p,q,R)` for naming all ordinal numbers, finite & infinite. Our system Box adds and uploads a number base from a primer, a number string `p = 1..` that can be naturally bounded or `ω` unbounded. The main rule adds this fixed `p` to accumulate a quantity in a variable string `q`. System Box counts down indices in its right subarray `R`, to upload multiplication factors, powers and superpowers, ever further…

Important is that `Box(ω,q,R)` uniquely expressly all ordinal numbers, from just the infinite primer `ω`, a natural quantity `q` and finite indices for the rest. When position is preserved, as in an Ox byte register, this can be achieved without the optional separators, just by concurrent number digits.

With the primer `1≤p<<ω` a finite number, the Box arrays function as an extended radix system, where separators can optionally be inserted to mark factors, exponents, etc.
Separators concisely express Big numbers, when large series of `0,` entries are kept implicit, and we restore subordinate array spaces, by applying separator specific upsize rules.

• Box 0. p,q = q (result)
• Box 1. p,X,[S] = p,X (trail off) with ,[] ≡ ,
• Box 2. p,q.,[Si]..,1Z :r (`r=0` main) = p,q.,[Si]..p,Z :r (`r≥1` upload)
• Box 3. p,q.,[Si]..,[1T]1Z :r0 (upsize) = p,q.,[Si]..,[T]..1,[1T]Z :r :p
• Box 4. p,X,[S],[T]Z {S<T} = p,X,[T]Z (sep out)
• Box etc. upload to separrays, deep nesting, etc.

The Box function is slow compared to Btrix, but it will catch up on a far away day, when deep separator structures begin to dominate the rules of the algorithm.
For now some examples that help fine-tune the upsizes in Box (you can make sure).

• Box(ω,q,n) = ω,ωq,n- = ω*n+q
• ω,,,1 = ω,0,ω = ω^2
• ω,,,,1 = ω,0,0,ω = ω,0,ω,ω- = ω^3
• ω,,[1]1 = ω,.,[0]..1 = ω,.0,..ω :ω- = ω^ω
• ω,,[1],[1]1 = ω,,[1],{ω-}ω = ω,ω^^2,[1].ω-,.. = ω^^2^2

The simplified Ox system below also counts `p=ω` up, but unlike Box it does not define separators. So we directly express all ordinals, but infinite sizes after `ω*2^r < ω^2` are problematic. If we notate lengths of `0{r≥ω}` bits recursively, subarrays creep in again.

For finite digits the automatic upload in the Ox radix system is simply amazing. When an index entry is counted down to `0`, and it has a right neighbour digit of `1` or more, then a number base `10` is (as it were) virtually uploaded. Keeping radix `ω` sized positions, a byte based Ox will bite `1` bits off on the left, while adding the primer `ω` to the quantity `q`.

• Ox 0. p,q,0{r} = q (result)
• Ox 1. p,q,0{r0}1Z = p,pq,1{r}0Z (only rule)

In computer hardware the commas of these arrays addressed as bytes. A byte nowadays is `8` bits long, so with room for `2^8` digits the number base `256` is a full register, notated in hexadecimals as `<:001` in Intel's little endian bit/byte mode.
We can subtract `1` from a right entry, let it float off, to automatically fill the left byte with `255<:ff` the largest digit. (Or have a smaller largest digit, for bytes to represent NaN characters, for example two less when `254<:ef` is an opening bracket and `255<:ff` its closing sign.)

The state of the `<:00` byte is void if the next byte is `<:00` (or NaN), and else its state is the virtual base `p`, ready for count down. When all void states are kept in place in the structure, there's no actual upward transport of numbers or array sizes. We just count off right bits.

For example in radix `p=256` reduce the number `132358<:605020` from byte form to a string of ones, by addition in a byte Ox machine, where indices have fixed positions. We write decimals and put commas in between to aid the human eye.

```1{256},6,5,2 = p,111111,5,2  with p = 1{256}
= p,1{262},4,2 == p,1{1286},0,2
= p,1{1542},255,1 = p,1{66822},0,1
= p,1{67078},255,0 == p,1{132358},0,0 = 1{132358}```

Because Ox expresses all whole numbers uniquely, these arrays have the same resolution as a radix system. In every byte entry an `2^k` length of ones is written with `k` bits. Representing each byte by a digit sign, expression size is up to a factor `2^k` smaller than its string `1..` evaluation.

By keeping entries `<:00` in place, there is no need for separators in Ox. Virtual separators may signify higher powers, but the next endian bit counts off the same as every other.
With shortcuts by separators in Box some famous numbers shrink in expression size, but the large bulk of random numbers escapes the mathematical net.

After the point in *3 where tetration is expressed directly (by an index over array nesting depth) the radix arrays of Box increase at the same rate as our system Nix, which just drops separators (and their subarrays) to collect `1..` the remaining entries.
Note that Bird classifies his array spaces by counting separators (or say he adds each entry as `1`). This lags a multiplication factor behind Nix, so after powers are expressed Bird runs on a par, meeting at Nix ~1 (by an index over array dimensions).

Both the byte entries in the Ox machine and the upsize rule `3.` in the Box algorithm, suggest that we should generally place the first couple `p,q` (primer and quantity) outside of the array proper, which consists of indices and their recursive structures in array functions.

The `ω` byte radix system is like “riding the ox”, an enigma.
Mind you, that `2^ω` in ordinal `o=` arithmetic becomes `ω`.

Ordinal naming by `O` is similar to `Box`, but `O` counts down to `1` so there are no empty entries, and a primer is missing: the atom `ω`, that is here implicitly added and uploaded.
Continue on the 4th entry of the row, which counts up to the next infinite multiplication.

```ω^3 ≤ O(1,1,1,1)
ω^3+ω ≤ O(1,2,1,1)
ω^3+ω^2 ≤ O(1,1,2,1)
ω^3+ω^3 ≤ O(1,1,1,2)
ω^4 ≤ O(1,1,1,1,1)```

In model `O` every entry in row space holds a factor `ω`, counting a power. So by row length we can express a first exponent directly. And an unbounded number of entries raises a power `ω`.

```ω^r ≤ O(.1,..) :r1
ω^ω ≤ O(1,,1)
ω^ω*2 ≤ O(1,,2)
ω^ω1 ≤ O(1,,1,1)
ω^ω2 ≤ O(1,,1,1,1)```

In model `O` the smallest index is `1`, and because there are no empty entries, we may use multiple commas `,..` to separate dimensions.
Progress to fill a plane of rows and then a cube to start to count a second exponent.

```ω^(ω*2) ≤ O(1,,1,,1)
ω^ω^2 ≤ O(1,,,1)
ω^(ω^2+ω) ≤ O(1,,,1,,1)
ω^(ω^2*2) ≤ O(1,,,1,,,1)
ω^ω^3 ≤ O(1,,,,1)```

If we know the ordinal related to each index position in `O`, and add all together, we obtain the higher infinite result. Then `O` offers a way of writing all numbers, natural and infinite, without resort to Cantor's `ω` style signs. No infinity is left behind and each expression of `O` is unique, like in a radix system. However, to us the `Box` system, with its primer `ω`, looks more natural.

### §2.0.4. Walks past omega

Given an infinite set, the paths we take to enumerate all elements, times our walking speed (index per natural number), results in some ordinal number in the endless end, as expressed by a general ordinal `Box(ω,0,R)` array function (see previous section).
For example, for a set composed of two subsets of omega numbers (two `ω` size rows), we arrive at `ω*2` `=` `Box(ω,0,2)` by counting each element once. We believe that Cantor does too, when he merges the two rows together by one-to-one enumeration. To reach infinity Cantor still has to take a two-step jump `ωω`, moving over omega two times!

Compare another enumeration of two infinite rows: how to count the even and odd numbers. Whether it is the cardinality `ω` of the natural numbers counted even-to-odd, or counting separately the `2` unbounded rows `/2` natural numbers per index: the one-step at the end of the index row amounts to `ω` in both cases.
In the latter case we walk on average by half a shared index per natural number, so the counting ends when we jump twice by half an infinite `ω/2` index. We should be able to switch enumeration styles without affecting the total number of elements.

```0~0, 2~1, 4~2, 6~3, ... m~m/2 ,, (even number)
1~0, 3~1, 5~2, 7~3, ... n~(n-1)/2 ,, (odd number)```

Sets of cardinality `2^ω` are not that different from the smaller sets of sizes `ω*n` and `ω^n`, which can be assessed one-to-one. There is a path over multiple dimensions, eventually taking `n^n` type steps, where all `ω` sizes are skipped over in one `ω^ω` infinite jump.
This method of Expanding Triangles from a Corner was applied by Georg Cantor in his diagonal enumeration of the rational numbers on a plane array. At the time he couldn't believe it, but infinite dimensional arrays are likewise countable.

We may dismiss the continuum hypothesis, when the elements of an infinite set `n^ω` can be put into one-to-one correspondence with all of its subsets. Obviously the cardinality of the powerset `2^ω` `=` `Box(ω,0,0,1)` of natural numbers cannot be of a higher `ω1` `>>` `Box(ω,X)` infinity, surpassing all general recursive functions over `ω0` omega.
The proof of Cantor's theorem looks convoluted, and we suspect its rigorous definition will be flawed by an infinite text loop (apply that link to gain fame). Which makes us wonder, how can such a mistaken idea be of use for so long?

We illustrate our claims with a few clickable examples, in conventional arithmetical format. The set theorist would find the use of Davies-trees better justified here.
We just apply the smart counting of well ordered sets that Cantor invented to bring higher number constructs down to the natural numbers by one-to-one correspondence.

• For the set of integers, we can enumerate the two rows of positive `n` and negative `-n` integers in parallel. Either count `-0` to start the negatives, or from `-1` as usual.
``` 0~0, 1~2, 2~4, 3~6, ... n~n*2 ,, (even index)
-0~1,-1~3,-2~5,-3~7, ...-n~n*2+1 ,, (odd index)```
Here we have one row of indices, but it takes two indices to get the next natural number. At infinity `ω` we'd jump once `*1` over two `*2` end indices (instead of `*2` jumps over `*1` number), so walking over the integers amounts to `ω*2` (any way).
We can bring more number sets back to a single count. An array could be filled by `n` finite rows of `ω` size, or by an infinite `ω` number of rows of equal size `n`. How can these planar sets total either `ω*n` (our elected cardinal) or `n*ω` `o=` `ω` (by Cantor's ordinal reduction) elements, depending on the path of enumeration?
And what if two `ω` sides form an infinite square?
• The set of rational numbers `m*x = n` with positive denominator `m` and numerator `n` can be projected on a plane array (or two planes `±n` in parallel).
Cantor found a way to enumerate these rationals over its diagonals, starting from the smallest (top) corner.
```0/1~0 ,1/1~1 ,2/1~3 ,3/1~6 ,4/1~10, ... n~(n-1)*n/2-1 ,,
0/2~2 ,1/2~4 ,2/2~7 ,3/2~11,4/2~16, ... ,
0/3~5 ,1/3~8 ,2/3~12,3/3~17,4/3~23, ... ,
0/4~9 ,1/4~13,2/4~18,3/4~24, ... ,
0/5~14,1/5~19,2/5~25, ... n/m~(m+n-1)*(m+n)/2+n-1 ,,,```
Here we have `ω` rows of size `ω`, enumerating `ω^2` positive rationals in total. At the time Cantor makes his infinite jump the average number `n` is at index `n^2`, which wraps it up.
If a whole plane can be counted by an index row, plane after plane reduces to a number of rows, enumerable by a single row of index indexes. Same for a cube, etcetera, up to multiple dimensions.
Now what if the number of dimensions becomes infinite?
• The equations `c0` `= ±ci*x^i..` `:d` that express all complex algebraic numbers `x` can be represented by a multidimensional array of `d` twin `±` dimensions and sizes `c`. Make rational coefficients fit in by multiplication with a common denominator.
Cantor cleverly mixed algebraic and ordinal tricks in his proof that the different `x` are countable to infinity. For a true one-to-one correspondence of the algebraic set with the natural numbers, its coefficients `ci` in multiple dimensions should be counted diagonally, parallel in all dimensions, from the top corner onward.
We would estimate their total at `ω^ω`, because there are about that many algebraic equations, and not many result in the same complex number `x`.

Etc theorem: Represent the set `2^ω` of subsets of the natural numbers, and the decimal embedding `n^ω` of the real numbers, in well-ordered multidimensional arrays of sizes `n`. Then all entries can be enumerated one-to-one, starting from the smallest corner, walking over expanding dimensional triangles (simplexes, or vertex figures) up to infinity.
This method of Enumeration by Triangles from a Corner will work for hyper arrays too.

Unleash triangles `Δ=Δ2`, tetrahedrons `Δ3` and higher simplexes `Δd` (orthogonal) over the `ω^ω` array. Simplexes are enumerated by the formula of binomial coefficients or combinations `nCk` `= n!/k!/(n-k)!` for `n=d+s-1` choose `k=s-1` with size `s=d` or `s=d+1` in dimension `1δd`.
Note that `ss-Cs-``*2` `=` `ssCs` from Pascal's triangle helps to see the enumeration formula for important simplexes, as below.

The subset of binary arrays `2^ω` shows only `0` or `1` signs inside. Right zero `0` entries are implicit, so we start from the empty `[0]` initial point in the top corner.
Click to enumerate more arrays on the proof sheet.

````[]1,` point of size `1` on the first row `1δ1` is enumerated `1C0=1`
`[1]2, [0,1]3,` triangle `Δ` of size `2` on plane `1δ2` enum `3C1=3`
[2]4, `[1,1]5,` [0,2]6, triangle `Δ` size `3` on `1δ2`enum `4C2=6`
`[0,0,1]7,` inner `Δ3` `[],[1],[0,1],[0,0,1]` size `2` in cubic `1δ3`
`[1,0,1]8, [0,1,1]9,` triangle `Δ` size `2` on `2δ2`
[0,0,2]10, tetrahedron `Δ3` size `3` in cubic `1δ3` enum `5C2=10`
[3]11, [2,1]12, [1,2]13, [0,3]14, `Δ` size `4` on `1δ2`
[2,0,1]15, `[1,1,1]16,` [0,2,1]17, `Δ` size `3` on `2δ2`
[1,0,2]18, [0,1,2]19, `Δ` size `2` on `3δ2`
[0,0,3]20, `Δ3` size `4` in `1δ3` enum `6C3=20`
`[0,0,0,1]21,` inner `Δ4` `[],[1],[0,1],[0,0,1],[0,0,0,1]` size `2` in `1δ4`
`[1,0,0,1]22, [0,1,0,1]23,` `Δ` size `2` in `1δ2,2δ3`
[2,0,0,1]24, `[1,1,0,1]25,` [0,2,0,1]26, `Δ` size `3` in `1δ2,2δ3`
`[0,0,1,1]27,` inner `Δ3` size `2` in `2δ3`
`[1,0,1,1]28, [0,1,1,1]29,` `Δ` size `2` in `2δ2,2δ3`
[0,0,2,1]30, tetrahedron `Δ3` size `3` in `2δ3`
[0,0,0,2]31, inner `Δ4` size `3` in `1δ4`
[1,0,0,2]32, [0,1,0,2]33, `Δ` size `2` in `1δ2,3δ3`
[0,0,1,2]34, `Δ3` size `2` in `3δ3`
[0,0,0,3]35, 4-simplex `Δ4` size `4` in `1δ4` enum `7C3=35`  ...
[0,0,0,4]70, `Δ4` size `5` in `1δ4` enum `8C4=70`
`[0,0,0,0,1]71,` inner `Δ5` size `2` in `1δ5`
[0,0,0,0,4]126, `Δ5` size `5` in `1δ5` enum `9C4=126`
[0,0,0,0,5]252, `Δ5` size `6` in `1δ5` enum `10C5=252`
[0,0,0,0,0,5]462, `Δ6` size `6` in `1δ6` enum `11C5`
[0,0,0,0,0,6]924, `Δ6` size `7` in `1δ6` enum `12C6`
[0,0,0,0,0,0,6]1716, `Δ7` size `7` enum `13C6`
[0,0,0,0,0,0,7]3432, `Δ7` size `8` enum `14C7`
[0,0,0,0,0,0,0,7]6435, `Δ8` size `8` enum `15C7`
[0,0,0,0,0,0,0,8]12870, `Δ8` size `9` enum `16C8`  ...
[.0,..,d-]c :d-, `Δd` size `d` in `1δd` enum `dd-Cd-=c`
[.0,..,d]c+c :d-, `Δd` size `d1` in `1δd` enum `ddCd=cc`   Etc.   Show all```

The primal (first in their dimension `1δd`) simplexes `Δd` of size `d1` are enumerated on the backbone of Pascal's triangle – call them pingala simplexes. Preceding top left in Pascal's triangle lie the primal simplexes `Δd` of size `d` – the ida simplexes.
We relate the sum of array entries to the dimensional expansion. Our Etc algorithm walks through all arrays where the sum of entries is `d` before it enters the next array entry `[.0,..1]cc1 :d` of the initial simplex `Δd1` of size `2` in a new dimension `δd1`.
When we create an ida simplex `Δd` with the array `[.0,..d-]` all arrays whose entries add up to `d-` have been covered. Previously to this ida we've counted almost all arrays of length `d` that contain just `0` and `1` entries (bit values). Only array `[.1,..]` `:d` is missing, but it is a point inside the next pingala simplex.
At that sushumna point – to continue our yoga analogy – before the `Δd` pingala, for sure we've reached all `2^d` multidimensional arrays to enumerate the subsets of a set of size `d`.
For consider `0` means that an element is missing from the set of natural numbers, and `1` at row entry `n` means that number `n` is present, then all arrays that form the ida `Δω` simplex contain the smaller subsets of the natural numbers (add one sushumna for the full set).
A multidimensional simplex `Δω` on this path covers a lot of array points, but at least all `[.1,..]` `:ω` arrays, while every next `Δd` simplex-step expands over `2` Pascal's rows `n`.

Remember from Pascal's triangle that `2^ω` is itself a way to smart count all combinations (or subsets) on the last row between infinitely many points (or elements). Even if we use sizes `ω` instead of `2` we can achieve one-to-one correspondence in all array dimensions `ω^ω` (such as the coefficient array for the algebraic numbers) by repeatedly walking over `Δd` simplexes, until `Δω` is jumped over at infinity.

So infinite sets of cardinality `2^ω` and `ω^^2` can be put in one-to-one correspondence with the natural numbers. Likewise iterative Beth subsets `2^^n+^ω` and all higher infinite set and tree structures (that set theorists assumed to require higher cardinals, even past the Church-Kleene ordinal!) can be cornered into one-to-one correspondence with the natural numbers by Etc over Beaf array structures (matched to their higher ordinals by Chris Bird).

We reach the conclusion that the concept of one-to-one correspondence invented by Cantor is utterly useless.
His square of rationals should count up to `ω^2`, cardinal of the infinite plane. To the finite eye this plane may appear half-done when the triangle counts its `ω/1` and `1/ω` vertices (as such) up to `ω`. But at that stage there are an `ω-` number of numerator-denominator rows that haven't jumped to infinity yet. They sum up to `ω*ω` brothers!

Above we proved that all multidimensional arrays can be enumerated by simplexes up to infinity. One such simplex covers even less of the vastness `ω^ω` of dimensional spaces, so to reduce them all to a single `ω` is just not done.
Ordinal `ω` reduction by Cantor's method of diagonalization can be pursued to hyper-dimensions `ω^^n` and further. Arguably this type of cardinal has had its omega days.

We will provide the separators in `O` with subscripts. Define `,[]` `≡ ,` at the initial index `0`, so that `,[1]` `≡ ,,` separates array rows. Multiple dimensions up to infinity `,[ω]` `≡ ,..` cover the next power.
Compared to the usual array functions our `O` naming model is moving terribly slow.

```ω^ω^m ≤ O(1,[m]1)
ω^^3 ≤ O(1,[1,1]1)
ω^^3*ω ≤ O(1,[1,1]1,1)
ω^^3*ω^ω ≤ O(1,[1,1]1,[1]1)
ω^^3^2 ≤ O(1,[1,1]1,[1,1]1)```

An infinite sequence of same separators raises that separator's ordinal to the power `ω`. Keen observations like these help us work out power towers in `O` until they cover `ε0` completely.

```ω^ω^ω1 ≤ O(1,[2,1]1)
ω^ω^ωω ≤ O(1,[1,2]1)
ω^ω^ω^2 ≤ O(1,[1,1,1]1)
ω^ω^ω^3 ≤ O(1,[1,1,1,1]1)
ω^^4 ≤ O(1,[1,,1]1)```

Progression of ordinal names in `O` compares neatly to our Nix classification of array structures. See Nix from rows ~1 ~2 ~3 ~4 to separator nesting depth. In an infinite version of Nix all entries/dimensions get value/size `ω` and then all separators are dropped to add the omegas.

```ω^ω^(ω^ω+1) ≤ O(1,[2,[1]1]1)
ω^ω^(ω^ω*2) ≤ O(1,[1,[1]2]1)
ω^ω^ω^(ω*2) ≤ O(1,[1,[1]1,[1]1]1)
ω^ω^ω^ω^2 ≤ O(1,[1,[2]1]1)
ω^^5 ≤ O(1,[1,[1,1]1]1)```

Bicycle `O` is just an exponent `^ω` or “wheel” ahead of the infinite Nix bike, so from tetration onwards both are equal. When structures are similar in two systems the resulting numbers tend to equalize. Here `O` and Nix meet at `ω` nesting depth.

```ω^^(n*2) ≤ O(1.,[1..]1.) :n:
(insert one `1` to separate `,,` a row space)```
```ω^^(n*2+1) ≤ O(.1,[..]1.) :n1:
(nest a void separator `,[]` to add an entry)```

From previous examples we extrapolated that separator nesting depth in `O` expresses tetration. Nesting our “two wheels” (entry & row) in `O` arrays to `ω` depth opens the next superpower class of ordinals at `ω^^(ω*2)` `≥ ω^^ω+^^ω` which is `ε1`, the epsilon one limit.

How does an array for `^{t}ω` superpowers fit in our system? We feel both bicycles `O` and Nix are destined to run on a par with motorcycle `Btrix(ω,X)` eventually and from there on with Bird's arrays (prime entry set to `a=ω`) and Bowers' airplane. But this still needs proof.

## by Giga Gerard mathematical artist ↑

People can read this article plain or choose the `hard` & fast & open version.