## §2.1. Omega jumps

What do people know? A function can grow Bigger than a function! In the Omega past the stairway…

### §2.1.1. Arrays of omega

If mathematicians lived eternally
they could write endless numbers `1..`

and repeat functions without bounds.
Omega `ω`

is the first infinite number past counting,
but it is also Bigger than `>>`

any computable function
`F(`

**X**)`= n`

with finite input `X`

and output `n`

.
Compared to jumping to `ω`

the growth rate of all finite functions is equally slow.

A general recursive or *computable* function `F`

over the natural numbers, no matter how complex,
is by definition reduced to an output number `n`

,
simply a bounded series
`1`

of ones.
Irrespective of the method of incrementation,
no matter how giant the steps we take, if we only write finite variables
our results remain in the natural realm.*..**:n*

General recursion is just repetition and indexing defined by a function
or some rule system (like our Btrix).
Any finite recursion always produces finite numbers.
Most primitive is the successor function
`1(`

that adds **n**)`1`

to get the next number.
On the other end of the recursive spectrum are the complex
algorithms we devised in the previous part of the book
to create Big record numbers.
But infinity can never be reached by finite means,
neither by simple counting, nor by recursions
in an explosively growing array function.

Let `G`

be an ever increasing function,
so that `G(`

**x1**)`> G(`

for all **x**)`x`

.

In the context of Big numbers `G(`

is a single variable shortcut for some maximal
**x**)`F(`

array algorithm.
Because any separator and structure type can be indexed,
maximal entry **AxZ**)`x`

in `G`

will represent recursion over the highest structure in `F`

.

For finite number input in `G`

the output is finite too.
With infinity `ω`

a Bigger order opens up.

ω >> G(n)

Repetition over omega will output the infinite ordinals.
After `ω`

come
`ω1`

, `ω2`

,
`ωω`

, `ωωω`

,
`ω^2`

, `ω^^2`

,
`ω^`

, etc…
Read any
^{..}2introduction to ordinal arithmetic

.

Infinite functions or operations (e.g. powers `ω^ω`

)
can be repeated (in a power tower)
and indexed to infinity
(up to `ε`

_{0}`= ω^^ω`

tetration).
Georg Cantor applied this principle over and over,
to base his infinite universe of sets
on transfinite counting over natural indices.

G(ω) > ω

Here we've beaten Cantor's counting past `ω`

and `2^ω`

by general recursion
`G(`

over omega.
This simplistic comparison covers
the common class of ordinal numbers, in one go.**ω**)

In last section the radix arrays of
Box
uniquely named all ordinals, starting from omega.
With input `ω`

functions of
Btrix and Bird
produce higher infinities much faster.
However, no fast rule system can create a larger number
that a slow rule system cannot express
with the help of some advanced structure.
With this in mind none of the recursive ordinals
`G(`

should be classified
functionally **ω**)`>>`

Bigger than omega
`ω`

.

Transcend this initial set of ordinals,
by extrapolating Cantor's principle of omega
(as the upper bound of a boundless set)
to jump from infinite computability
`G(`

too.**ω**)

We will create such `>>`

large cardinals
after a thorough discussion of the real numbers.

### §2.1.2. Catching all reals

It is unclear how infinite the number of all
real numbers
is. Can it be `2^ω`

as the
continuum hypothesis
holds? What is Cohen's proof that this is unprovable? The
debate
rages on!

The result depends on the
topology
of the real number line.
What functions do we expand the set of real numbers with?
Can we add new subsets and slowly,
recursively attain them all?
Or will most of the random fish always escape the net
and stay unaccounted for?

To get on top of the reals,
most inverse operations haven't been realised yet.
The
super-roots
and
super-logarithms
of *tetration* for example, extendable by
Abel functions.
We'd like to inversely iterate over operator indices in
Ackermann functions
and further, into an inverse
fast-growing hierarchy
perhaps…

Various array functions can have their own inverses,
all mixable beyond recognition,
classified as *real* when we count those numbers in,
or superreal
when superexponential inverses are kept out of the proper set of real numbers.
But in our opinion
all inversely constructed numbers are likewise real.

Below we sketch how inverse superpower operators work,
in a new `-*`

notation.*{p}*

With minority precedence of stars
`-*`

over `*`

over `**`

and majority precedence of caret `^`

powers.
A trailing right minus sign `-`

equals

minus one.**-**1

- a = b*
^{..}c**:p* - a
**-**c = b by subtraction`{p`

negative integers*=*0} - a/c = a
**-***c = a*1**-***c = a*c**- = b by division`{p`

rationals*=*1} -
^{c}√a = a^(1/c) = a**1**-***c^{ }= a**c**- = b by roots`{p`

algebraic reals*=*2} -
^{a}log b = log(b)/log(a) = log(b)*log(a)^-^{ }= a**-****b = c logarithms`{p`

*=*2} - a*
*{p}*c**- = b roots of superpowers - a
**-***b = c logarithms of superpowers*{p}*

The new number sets and their combinations
are superexponential versions of the
algebraic numbers,
which we
count
as an `ω^ω`

size set
(reduced

to
_{o}=`ω`

by
Cantor).

Even though the
diagonal proof
of Cantor is given within the expansion of some
`10^ω`

radix expressions,
we agree that the cardinality of the real numbers is of a different order,
because their realm cannot be chartered by stepwise inclusion
of a finite number of new types.

The embedding of higher inverse numbers
in a single number system does no justice to them all.
Just as infinite fractions approximate `√2`

very well,
but no fraction is an exact match,
these exotic reals may float an infinite pool of binary digits,
but it is the wrong medium to dissolve them in.

To our surprise Cantor's real cardinal `2^ω`

is quite small (pretty nearby).
Instead, if we index all inverse function types,
we get as many unique superreal field units
as can be constructed in an array function
`G(`

and about **ω**)`G(`

real number combinations too (the **ω**)*combination*
operation becomes negligible at this scale).

If we translate the natural numbers `1..`

to binary base (in digits `0`

and `1`

),
their cardinal number or total will be `ω`

as before, given an expression length of

at most.
While at digit length ^{2}log ω`ω`

we'd count
`2^ω`

unique binary series,
what length does it take to embed (binary express)
all the real numbers in?

Introducing a decimal dot is less relevant,
because the fractional digit series is a mirror image
of the whole number series,
which at infinity share the same cardinality.
Until infinity is reached Cantor's diagonal argument
just proves that marginal cases derived from
the binary expansion of the reals escape the net.

In a non-unique radix
`1`

a single number can be rendered by various binary strings.
For some *<*r*<*2`r`

the usual plane diagonal argument
for the reals would fail, because of the extra number space.
We think there exist enough such `r`

to counter every plane diagonal type argument.

Higher simplex type diagonal arguments may require superreals as
counterarguments, but still they won't dominate the main set.
Cantor's super-diagonal reals
will never contribute significantly to the total of real numbers.
And surely not at the height,
where all functional differences blur:
maximal general recursion with an omega argument.

G(ω) ~ 2^G(ω) ~ F(G()ω)~ G()..ω..:ω:or:G(ω):etc.

So the set of inverse functional or
*non-random* reals has approximately
`G(`

elements.`ω`

)

Now does it matter (at this scale),
if the majority of the real numbers is not constructed by algorithm,
but their cardinal matches the *random*
variation possible in their
`G(`

infinite embeddings? Hardly!`ω`

)

In the Big arrays represented by `G`

the number of structures (embeddings)
and the numbers expressible (the variation) in those structures
tend towards the same limit rather quickly.
In the end there is no way for a maximal entry
to transcend a maximal separator type.

When the difference between expression size
and the number expressed falls away with the next structure in an
`G(`

array,
algorithmic determination and randomness merge to one.
Just as an **ω**)`ω`

length of digits
and its total `10^ω`

number
are dwarfed by `ω^^2`

next.

We've travelled the infinite realm by iterating over
`ω`

, within a maximal `G`

array function.
Now a Bigger infinity can be defined
on top of all infinite general recursions.

`ω`_{1} **>>** G(**ω**)

In this chapter, to go higher than the number of reals we had to
*jump from omega*, past all infinite
`G(`

expressions,
to the next **ω**)`ω`

infinity.
Like Cantor once jumped with _{1}`ω`

or
`ω`

from natural numbers _{0}`n`

and from finite functions `G(`

for that matter.**n**)

If what we did in last chapter:
counting further from the virtual end
`ω`

of counting, had complete bearing on the _{0}reality

of functions, what realm of existence opens with
`ω`

?_{1}

### §2.1.3. Higher omega

We've assumed an initial infinity
`ω`

to exist above _{0}`>>`

the finite constructions `G(`

that express natural numbers.
And last section found the next higher omega
**n**)`ω`

on top _{1}`>>`

of the infinite arrays
`G(`

to enumerate the real numbers,
expressed by all recursive functions and their
**ω _{0}**)

`ω`_{0}

infinite inverse units.Similarly the new omega can be input in

`G(`**ω**_{1})

at the 2nd level of ordinal infinity,
whose numbers in turn require a Bigger omega
`ω`_{2}

to close the complete set.
The `ω`

that came next is the least non-computable ordinal of
Church-Kleene.
Then follows the enumeration _{1}`ω`

of computable infinity levels. How?_{j}

Any next `ω`

jumps above all numbers that can be constructed by
_{j1}

infinite time
Turing machines
in a
*≤*ω_{j}

infinite
hyperarithmetical
order (or even higher
*≤*ω_{j}

iteror).*≤*ω_{j}

Because `ω`

computability
includes any algorithmic routine or
Gödel encoding
(or worse)
indexed up to _{j}`ω`

.
All those types come for free with the expression
_{j}`G(`

by essentially recursive methods taken to their extremes.**ω _{j}**)

In maximal function

`G`

we have the most general view possible of recursion.
The axiomatic refinements and language hierarchies issued from
forcing
set theory are skipped over, fast and rough.
Like when we met the powersets
`2^..ω`

of natural numbers early in `G(`**ω**)

,
many types of higher cardinals important in set theory
are simply blasted away.
The `ω`

in function _{j}`G`

exist on a separate infinite level
of recursion or computation.
And we can always issue a next higher omega
`ω`

that _{j1}counts

all lower infinite number variations,
down to include the finite, by definition.

`G(`**ω**_{j}) **>** ω_{j}
ω_{j1} **>>** G(**ω**_{j})

Every infinite jump `ω`

beyond numbers computable in _{j}`G`

can be indexed.
Here we will count such jumps `j`

in a Bigger function
Omega `Ω`

,
which expands subscripts to arrays.

A next greater infinity in Omega `Ω`

is impossible to reach `>`

by any maximal array function `G`

at the current infinite level. It is only possible to
`>>`

define them as jumps.

We place the jump from `n`

to `ω`

(from counting a number to all counting numbers)
at the initial `Ω(`

infinite function. Then leaving out the number **0**)`0`

as void,
and dropping the brackets, we set
`Ω = ω`

to rule over the natural numbers.

Later we'll see a notation without brackets, where
`Ω`

are evaluated from the right.
Note for now that `Ω`

can be both an infinite atom and an infinite level function.

Omega at index minus one
`Ω(`

might equal **-**)`1`

by convention,
or any natural number `n`

as below.
With `n`

in `G`

we present our maximal finite number `Gn`

mister Big

`m`

.

`Ω() = ω `**>>** G(**n**)
Ω(**a1**) = ω_{a1} **>>** G(**Ω(****a**))

So the higher infinite is built up step by step,
or rather *jump by jump*, but indexed in natural order.
Just like counting next numbers `1,11,111,...`

we index `Ω,Ω1,Ω11,...`

the next infinities.
However, instead of incrementing to the successor,
the difference between infinite levels is actually made by
a complete computation over the predecessor,
with the idealized maximal `G`

functions as mediator.

The initial infinity `ω`

has led to a flourishing branch of modern set theory,
where various infinities in and above
`G(`

help to prove crucial facts in the foundation of mathematics.
Read
Akihiro Kanamori's
**ω**)The Higher Infinite,
large cardinals in set theory from their beginnings

,
to convince yourself that Bigger numbers do have use.

On Kanamori's
ladder
of higher infinities our next non-computable omega
`ω`

already moves well past the bottom rungs.
First the
weak limit
_{1}`+ω..`

and strong
inaccessibles
`^ω..`

,
then via predicative
Mahlo
(past the
Feferman-Schütte
ordinal) and the
indescribable
cardinals (past Gödel encoding), and per
measure
theory up to Woodin's
supercompact
and Reinhardt's
extendible
cardinals. Where in heaven's name is `Ω(`

?**a**)

We imagine
Vopenka
and
huge
cardinals, designed to count sets with certain properties,
to fall within the expressive power of rewrite recursion
`G(`

over indexable structures too.**ω**)

Sets
are just mathematical structures, isn't it?
The
set
universe doesn't even have
class.
And classes can be indexed, and indexes iterated over
up to infinity by recursion…

So
general recursion
always wins.

We are happy to call the first batch of these
`ω`

cardinals
recursively inaccessible,
and take it further from there.
To accept this position
in the nomenclature of infinities may sell us short,
but we'd like to see set theorists try to keep up!_{n}

### §2.1.4. Omega pair on stairs

Next we write an omega number of jumps `ΩΩ`

`= Ω(`

**ω**)`= ω`

as a pair _{ω}`Ω(`

in Omega.**0,2**)

Omega is a second type of function to count levels of infinity.
It is equivalent to a subarray structure on `ω`

,
which can be expanded maximally after the Big plan of general recursion.

Pairs in function Omega `Ω(`

express a staircase of **a,b**)`ω`

infinities.
These levels of omega, subscript upon subscript, have length `b`

and a natural number `a`

as ground index.

When parameter `b`

just the ground *=*0`a`

remains, no staircase.
In higher arrays we drop the `0`

of a right entry that is empty or counted down.
But here `Ω(`

**a,1**)`= Ω(`

is last.**a**)

In case `a`

the bottom *=*0`ω`

of the staircase can be left plain.
So to count jumps to infinity

by an
infinity of jumps to infinity

we take three steps
`ω`

_{ωω}`= Ω(`

in Omega.**0,3**)

Again `G`

is a general recursive function,
with supposed maximum growth rate,
that covers the level of infinity of its argument.
We jump-define a new infinity that is
`>>`

next Bigger.

An appended minus `-`

decrements the left number by `1`

,
but `ω`

_{1}-`>>`

`ω`

so take care!_{0}

- Ω(
**a,**) = a - Ω(
**,1**) = Ω() = ω**>>**G(**n**) = m*{m**<<*ω} - Ω(
**a,1**) = Ω(**a**) = ω_{a}**>>**G(**Ω(**) = G(**a-**)**ω**)_{a-} - Ω(
**a,2**) = Ω(**Ω(**) = ω**a**)_{ωa}**>>**G(**ω**)_{ωa-}**≈>>**G(**Ω(**)**G(**)**ω**)_{a-}**≈**Ω(**G(**)**ω**)_{a-}**>>**G(**ω**)_{ωa-}**>**ω_{ωa-}

By comparison `Ω(`

**-**)`= ω`

reduces to a natural number _{-} = G(**n**)`m`

, maximum Big.

Only the dominant `G`

in the expression,
that is its innermost limit iteration, survives
`≈>>`

reduction from the infinite to a max-finite index,
while other `G`

or `m`

are
`≈`

dropped.

To meet the next `Ω(`

we must iterate jumps **1X**)`>>`

from expression `Ω(`

in Omega.**X**)

If we continue our function
`Ω(`

with two entries and more, Omega soon takes the shape
of the Big array functions we know and love.**a,b**)

- Ω(
**,b1**) = Ω(**Ω(),b**) == Ω()*..**:b1:***Ω(**)**,b**)**>>**G(**Ω(**))*.*Ω(*..*)*.*-*:b:***≈>>**Ω(*..***G(****n**)*..*)*:b:* - Ω(
**a,b1**) = Ω(**Ω(**) == Ω(**a**),b)*..***a***..**:b1:***Ω(**)**a,b**)**>>**G(**Ω(**)**Ω(**)**a,b**)-**≈>>**Ω(**G(**)**ω**),b_{a-}

Omega pairs were fine-tuned to let `Ω`

function as an atom in a jump version of the
Btrix array system.
If we entertain the same upload methods from now on,
two theaters may run the same show:
the jump *function* `Ω`

solo,
and the higher *atom* `Ω`

to act with Btrix.

### §2.1.5. Jump function Omega

A stairway of infinite jumps can be recursively expanded,
either by function `Ω`

or as atom `Ω`

in an array function with upload.
Take symbol `Ω`

as initial entry in Btrix,
and shift the other parameters of Omega one entry to the right,
to act on this stage of Bigger numbers.

Omega with a single index `Ωn`

counts the number `n`

of `ω`

-type jumps.
From the variable pair onward
`Ω(`

**v,X**)`= Btrix(`

are equal, which can be **Ω,v,X**)`≡`

notated `Ω,v,X`

or as `v,X`

for convenience.

An example that translates to an
`ω`

infinite stairway of _{1}`ω`

subscripts.

- Ω(
**1,1,1**) = Ω(**Ω(**) = Ω(**1**),,1**,Ω(**)**1**)**Ω(),Ω(**) == Ω(**1**)-*..*)*:ω*_{1}: -
**>>**G.Ω(**Ω**)*{ω*-_{1}-}**≈>>**G.Ω(**Ω**)*{Gω}*-*{m**=*Gn*<<*ω}**≈>>**Ω(**Ω**)*{Gω-}*m**≈**ΩΩ*{Gω-}*= Ω*{Gω}* - Btrix(
**Ω,1,1,1**)**≡ Ω,1,1,1**= Ω*{Ω}*,1 = Ω,Ω*{Ω1}**..**:ω*_{1}

Expressions of Btrix are reduced completely,
when the 2nd entry (1st entry from `Ω`

)
has accumulated all iterations from the array expansion.
Internally `Ω`

atoms are appended on the left by rule.
The output `Ω..n`

(plain or in reps)
must be resolved from the right.

Counting `-..`

up to
`ω`

nests in the former function _{1}`Ω`

takes an infinity jump longer,
than to append `1`

plus `Ω`

atoms in the latter Btrix.
We do feel tricked when deus ex machina

the final number of repetitions
`Ω1`

is revealed here.

While Btrix applies the same
rules,
her expressive power with atom `Ω`

is so inaccessibly Bigger, that sizes
`Ω`

are too tiny to be contained
(without explicit *{ω+1}*`+`

sign).

A string `Ω1Ω1`

can be resolved from the right
`Ω1ω`

_{1}_{o}= Ωω_{1}`= ω`

by ordinal arithmetic, or else to
_{ω1}`ω`

if we like, but such sequences cannot be created in
Btrix
with _{ω1+1}`Ω`

atoms.

Given the sequence `w = Ω..`

of Omegas.
If we subtract one `-`

from the total,
the right `Ω-`

symbol at the end of `w`

is replaced
`≈>>`

by a maximum finite number
`G(`

**n**)`= m`

.

To subtract `Ω`

deletes it from the tail,
or subtracts `1`

from the quantifier of its series.
But with ever higher recursions in `w`

,
it is hard to know where this countdown by
`-`

takes effect.
After the last comparison `≈>>`

the problem of finding the natural quantifier will be resolved.

An example with `1`

tetration, `2`

powers
and `3`

multiplications applied to `Ω`

,
to add to `4`

so to speak.
We use `≡`

simplified notation in the evaluation,
which culminates in a higher infinite rewrite
*rep* `:`

for (and with) regex quantifiers `{}`

on both sides of the expression.

Btrix(Ω,4,3,2,1)≡ 4,3,2,1 == ΩΩΩ4,0,2,1 = Ω,ΩΩΩ4-,1,1 == Ω= Ω{ΩΩΩ4},0,1,1 = Ω,Ω{ΩΩΩ4}-,0,1 == Ω{Ω,0,0,1 = Ω,0,Ω{ΩΩΩ4}}{Ω- = Ω,Ω-,Ω{ΩΩΩ4}}{Ω-- == Ω{ΩΩΩ4}}{Ω},0,Ω{Ω-- == Ω{ΩΩΩ4}}{Ω,0,Ω{Ω}}{Ω--- ={ΩΩΩ4}}{..1..}:Ω{Ω:{ΩΩΩ4}}

What realm of infinity does this number rule over?
Calculate its predecessor in Omega.
We can use a dot as a left function bracket`.`

with
the right bracket missing at the end).

>>GΩ.Ω{-.Ω{..1..}.-}:Ω{Ω-:{ΩΩΩ4}}≈>>Ω{..}:GΩ.Ω{Ω:{ΩΩΩ4}-}-≈>>id:Ω{GΩ.Ω{ΩΩΩ4-}-}≈>>id:Ω{Ω{G.ΩΩΩ4-}}≈>>id:Ω{Ω{ΩG.ΩΩ4-}}≈>>id:Ω{Ω{ΩΩGω}_{3}}≥Btrix(Ω,Btrix()ω),2,2,1_{3},Z

You'll find the original Btrix
`Ω`

expression
easier to read than her evaluation
to repeated sequences of `Ω`

.
Remember that signs `Ω..`

are not to be added, subtracted from or otherwise
arithmetically combined in Btrix,
but that they refer to recursions
over a higher infinite staircase of omega jump levels.

In natural Btrix
we can also view repeated number units `1..`

as recursive functions: the initial successor function is repeated
to add a number, then uploaded to multiply,
for powers, superpowers, etc.
Such operator terms apply to Omega recursions too,
not to perform the actual operations,
but to classify the form of the array function.

Comparing series of omega `>>`

with maximal recursion in `G`

still is the axiom of foundation for jumps, but loses signifance
as a hierarchy of jump names develops in
Btrix `Ω`

of its own accord, so it would seem.

Evaluation of Btrix with `Ω`

atoms extends the staircase of omega `ω`

to mindboggling new over the horizons

.
How to make sure, that beyond nested `Ω`

arrays
we enjoy an endless smooth flight? Is there a systematic way
to fix the missing `Ω-`

fixed point problem for all?

Generalize the examples shown earlier in this section.
Evaluate arrays `Z`

to the penultimate word `w`

and subscript it under omega,
to mark the infinite jump `>>`

from all recursions in `G`

over the preceding omega
(with subscript decremented `w-`

by one).

`if Btrix(`**Ω,Z**) == Btrix(**Ω,v,1X**) = Btrix(**Ω,Ωv,X**)
== Btrix(**Ω,w,1**) = Ωw = ω_{w} **>>** G(**ω**_{w-})
**≈>>** Btrix(**Ω,G(****ω**_{v-}),X)
else == Btrix(**Ω,T,v,1X**) *{v**<<*ω}
**≈>>** Btrix(**Ω,T,G(****ω**_{v-}),X)

Arrays in Btrix develop over
entries, rows, dimensions and nested subarrays,
and are expected to fully catch up with Bird's
Beaf at `ω`

nesting depth.
For various array functions based on the higher infinite atom
`Ω`

, we expect the mutual evaluations
at various stages of their expansion
to compare just the same as with a natural number primer.

Bigger infinite arrays are ornamented with the very same structures
as Big finite arrays. We have no reason to believe
that combinations of signs,
alphabets, dictionaries, shelves, libraries, streets, cities, worlds,
etc, won't work out the same.

Now the jumps `Ω`

that are overall Bigger
`>>`

than their recursions are filled to the brim.
It's time for a third type of function.