# 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 selfproclaimed,
“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 onetoone 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 selfreflection 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 metastop 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 nontrivial 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,n_{1},n_{2})
Multiplication is to be continued on the row. Every next entry
n_{i}
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(N_{1}.P_{1})/O(N_{2}.P_{2})
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.,[S_{i}]..,1Z :r (
r=0
main) = p,q.,[S_{i}]..p,Z :r (r≥1
upload)  Box 3. p,q.,[S_{i}]..,[1T]1Z :r≥0 (upsize) = p,q.,[S_{i}]..,[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 finetune 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{r≥0}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
onetoone
enumeration.
To reach infinity Cantor still has to take a
twostep
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 eventoodd,
or counting separately the 2
unbounded rows
/2
natural numbers per index:
the onestep 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^{~(n1)/2} ,, (odd number)
Sets of cardinality 2^ω
are not that different from the smaller sets
of sizes ω*n
and ω^n
,
which can be assessed onetoone.
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 onetoone 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
Daviestrees
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 onetoone correspondence.

For the set of integers, we can
enumerate
the two rows of positive
n
and negativen
integers in parallel. Either count0
to start the negatives, or from1
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 byn
finite rows ofω
size, or by an infiniteω
number of rows of equal sizen
. How can these planar sets total eitherω*n
(our elected cardinal) orn*ω
_{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 denominatorm
and numeratorn
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^{~(n1)*n/21} ,, 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+n1)*(m+n)/2+n1} ,,,
Here we haveω
rows of sizeω
, enumeratingω^2
positive rationals in total. At the time Cantor makes his infinite jump the average numbern
is at indexn^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 ofindex indexes
. Same for a cube, etcetera, up to multiple dimensions.
Now what if the number of dimensions becomes infinite? 
The equations
c_{0}
= ±c_{i}*x^i..
:d
that express all complex algebraic numbersx
can be represented by a multidimensional array ofd
twin±
dimensions and sizesc
. Make rational coefficients fit in by multiplication with a common denominator.
Cantor cleverly mixed algebraic and ordinal tricks in his proof that the differentx
are countable to infinity. For a true onetoone correspondence of the algebraic set with the natural numbers, its coefficientsc_{i}
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 numberx
.
Etc theorem:
Represent the set 2^ω
of subsets of the natural numbers,
and the decimal embedding n^ω
of the real numbers,
in wellordered multidimensional arrays of sizes n
.
Then all entries can be enumerated onetoone,
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
^{n}C_{k}
= n!/k!/(nk)!
for n=d+s1
choose k=s1
with size s=d
or s=d+1
in dimension 1δ^{d}
.
Note that
^{ss}C_{s}
*2
=
^{ss}C_{s}
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 ^{1}C_{0}=1
[1]^{2}, [0,1]^{3},
triangle Δ
of size 2
on plane 1δ^{2}
enum ^{3}C_{1}=3
[2]^{4}, [1,1]^{5},
[0,2]^{6}, triangle Δ
size 3
on 1δ^{2}
enum ^{4}C_{2}=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 ^{5}C_{2}=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 ^{6}C_{3}=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}, 4simplex Δ^{4}
size 4
in 1δ^{4}
enum ^{7}C_{3}=35
...
[0,0,0,4]^{70}, Δ^{4}
size 5
in 1δ^{4}
enum ^{8}C_{4}=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 ^{9}C_{4}=126
[0,0,0,0,5]^{252}, Δ^{5}
size 6
in 1δ^{5}
enum ^{10}C_{5}=252
[0,0,0,0,0,5]^{462}, Δ^{6}
size 6
in 1δ^{6}
enum ^{11}C_{5}
[0,0,0,0,0,6]^{924}, Δ^{6}
size 7
in 1δ^{6}
enum ^{12}C_{6}
[0,0,0,0,0,0,6]^{1716}, Δ^{7}
size 7
enum ^{13}C_{6}
[0,0,0,0,0,0,7]^{3432}, Δ^{7}
size 8
enum ^{14}C_{7}
[0,0,0,0,0,0,0,7]^{6435}, Δ^{8}
size 8
enum ^{15}C_{7}
[0,0,0,0,0,0,0,8]^{12870}, Δ^{8}
size 9
enum ^{16}C_{8}
...
[.0,..,d]^{c} :d, Δ^{d}
size d
in 1δ^{d}
enum ^{dd}C_{d}=c
[.0,..,d]^{c+c} :d, Δ^{d}
size d1
in 1δ^{d}
enum ^{dd}C_{d}=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}
simplexstep 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 onetoone 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 onetoone 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
ChurchKleene
ordinal!)
can be cornered into onetoone 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 onetoone 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 halfdone
when the triangle counts its ω/1
and
1/ω
vertices (as such) up to
ω
.
But at that stage there are an ω
number of numeratordenominator 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 hyperdimensions
ω^^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 one1
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.