## §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..:n` 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.
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(n)` that adds `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(x)` for all `x`.
In the context of Big numbers `G(x)` is a single variable shortcut for some maximal `F(AxZ)` array algorithm. Because any separator and structure type can be indexed, maximal entry `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`, `ω^..2`, etc… Read any introduction 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 `-*{p}` notation.
With minority precedence of stars `-*` over `*` over `**` and majority precedence of caret `^` powers. A trailing right minus sign `-` equals `-1` minus one.

• a = b*..c *:p
• a-c = b by subtraction `{p=0}` negative integers
• a/c = a-*c = a*1-*c = a*c**- = b by division `{p=1}` rationals
• c√a = a^(1/c) = a**1-*c = a**c**- = b by roots `{p=2}` algebraic reals
• alog b = log(b)/log(a) = log(b)*log(a)^- = a-**b = c logarithms `{p=2}`
• a*{p}c**- = b roots of superpowers
• a-*{p}b = c logarithms of superpowers

The new number sets and their combinations are superexponential versions of the algebraic numbers, which we count as an `ω^ω` size set (reduced `o=` to `ω` 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 `2log ω` at most. While at digit length `ω` 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<r<2` a single number can be rendered by various binary strings. For some `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 `ω1` infinity. Like Cantor once jumped with `ω` or `ω0` from natural numbers `n` and from finite functions `G(n)` for that matter.
If what we did in last chapter: counting further from the virtual end `ω0` of counting, had complete bearing on the reality of functions, what realm of existence opens with `ω1`?

### §2.1.3. Higher omega

We've assumed an initial infinity `ω0` to exist above `>>` the finite constructions `G(n)` that express natural numbers. And last section found the next higher omega `ω1` on top `>>` of the infinite arrays `G(ω0)` to enumerate the real numbers, expressed by all recursive functions and their `ω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 `ω1` that came next is the least non-computable ordinal of Church-Kleene. Then follows the enumeration `ωj` of computable infinity levels. How?
Any next `ωj1` jumps above all numbers that can be constructed by `≤ωj` infinite time Turing machines in a `≤ωj` infinite hyperarithmetical order (or even higher `≤ωj` iteror).
Because `ωj` computability includes any algorithmic routine or Gödel encoding (or worse) indexed up to `ωj`. All those types come for free with the expression `G(ωj)` by essentially recursive methods taken to their extremes.
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 `ωj` in function `G` exist on a separate infinite level of recursion or computation. And we can always issue a next higher omega `ωj1` that counts all lower infinite number variations, down to include the finite, by definition.

```G(ωj) > ωj
ωj1 >> G(ωj)```

Every infinite jump `ωj` beyond numbers computable in `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 `Ω(0)` infinite function. Then leaving out the number `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 `ω1` already moves well past the bottom rungs. First the weak limit `+ω..` 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 `ωn` 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!

### §2.1.4. Omega pair on stairs

Next we write an omega number of jumps `ΩΩ` `= Ω(ω)` `= ωω` as a pair `Ω(0,2)` in Omega.
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 `Ω(a,b)` express a staircase of `ω` infinities. These levels of omega, subscript upon subscript, have length `b` and a natural number `a` as ground index.
When parameter `b=0` just the ground `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)` `= Ω(a)` is last.
In case `a=0` the bottom `ω` of the staircase can be left plain. So to count jumps to infinity by an infinity of jumps to infinity we take three steps `ωωω` `= Ω(0,3)` in Omega.

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-` `>>` `ω0` so take care!

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

By comparison `Ω(-)` `= ω- = G(n)` reduces to a natural number `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 `Ω(1X)` we must iterate jumps `>>` from expression `Ω(X)` in Omega.

If we continue our function `Ω(a,b)` with two entries and more, Omega soon takes the shape of the Big array functions we know and love.

• Ω(,b1) = Ω(Ω(),b) == Ω(..) :b1: = Ω(Ω(,b)) >> G(Ω(.Ω(..).-)) :b: ≈>> Ω(..G(n)..) :b:
• Ω(a,b1) = Ω(Ω(a),b) == Ω(..a..) :b1: = Ω(Ω(a,b)) >> G(Ω(Ω(a,b)-)) ≈>> Ω(G(ωa-),b)

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(Ω,v,X)` are equal, which can be `≡` notated `Ω,v,X` or as `v,X` for convenience.
An example that translates to an `ω1` infinite stairway of `ω` 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 = Ω,Ω,Ω == Ω,Ω{Ω},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 `ω1` nests in the former function `Ω` 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 `Ω{ω+1}` are too tiny to be contained (without explicit `+` sign).
A string `Ω1Ω1` can be resolved from the right `Ω1ω1` `o= Ωω1` `= ωω1` by ordinal arithmetic, or else to `ωω1+1` if we like, but such sequences cannot be created in Btrix with `Ω` 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
== Ω{Ω{ΩΩΩ4}},0,0,1 = Ω,0,Ω{Ω{ΩΩΩ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(ω3,Z),2,2,1)```

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.

## by Giga Gerard mathematical artist ↑

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