## # Royal infinities

Queen Máxima on global policy for the people: “I urge you to aim high!”

### # Jump recursion types

Summary of the main ideas of previous chapters:

We add units `1`

to form natural numbers
`1.. `

and produce the Big ones
in a general recursive function *:n*`F(`

over a finite matrix **X**)`X`

.
Up to maximum system `G(`

we know numbers will be finite,
because all repetitions come to a halt.**n**)

To add `1..`

without end means to jump
`>>`

to infinity,
namely omega `ω`

.
Substitution of omega in various
`F(`

results in the ordinal numbers up to a recursive maximum
**ω,X**)`G(`

.**ω**)

After all `ω`

we jump _{0}`>>`

to real number infinity in the
`ω`

realm.
Further jumps _{1}`>>`

over recursion over `ω`

_{n}`≡ Ωn`

expand to the omega
stairs
of atoms `Ω...n`

up to
`Ω(`

jump recursive size.**U**)

- Ω ≡ Ω() = ω
_{0}**>>**G(**n**) = 1*..**:m* - Ω(
**n**) = ω_{n}**>>**G(**ω**)_{n-} - Ω(
**U**) == Ω(**v,1**) = Ωv ≡ ω_{v}**>>**G(**ω**)_{v-}*{v**=*Ω_{0}...*<<<*Ω_{1}}

The universal matrix `Ω(`

on Omega contains just natural indexes.
It functions as an array **U**)`ω`

that names higher infinite omega.
Its reduction to a series _{{U}}`Ω...n`

of Omega signs in `v`

is appended right of the initial function atom
`Ω = Ω`

and not to be added, but as infinite indexes.
No sign in structure _{0}`U`

and the resulting series `v`

is an Omega type `>>>`

higher than the initial atom
`Ω`

._{0}

See last jump
section to make sense of
`v-`

that subtracts `1`

from the
`ω`

subscript staircase.

Now conjure up a maximal general recursive jump function
`H`

for a single variable, to counter the following issue:
Sequences of `Ω...`

output by different jump algorithms, such as
Box, Btrix
or Beaf where atoms `Ω`

are uploaded, may not arrive in the same order as results
of similar expressions with natural numbers or ordinals.
How to know for sure if a level so elusive as the
deepest structure

compares the same for all
`Ω`

inspired array functions?

A generic rewrite function `H`

selects an algorithm that maximizes output for some
`Ω`

atom input.
We can always choose those rules in _{t}`H`

that make all jump comparisons work out in an orderly manner,
optimized for constructions with any infinite atom.

From now on replace
`Ω`

by recursion in
_{t}(**U**)`H(`

over Omega jump types.**Ω _{t}**)

`H(`**n**) = G(**n**) = F_{max}(**X**) *{p**<<*ω in X}
H(**Ω**_{0}) **≈>>** G(**Ω**_{0}v) **>** Ω_{0}v

Remember how omegas
`ω`

came by jumping _{n1}`>>`

over all recursions over previous
`ω`

omega.
Now we are ready to define the first batch
_{n}`Ω`

of next Bigger
_{n1}`>>>`

Omega jumps.

Use the single dot as a left bracket
for a number group that runs to the right end.

`Ω`_{1} **>>>** H(**Ω**_{0})
H(**Ω**_{n}) **≈>>** Ω_{n}v **>>** G(**Ω**_{n}.v-) *{v**=*Ω_{n}...*<<<*Ω_{n1}}
Ω_{n1} **>>>** H(**Ω**_{n})

No atom Omega in the series `v`

has a higher index that the initial Omega on the left.

Eternally soon Omega receives infinite indexes.
Again only the inner limit functions remain.

`Ω`_{Ω} **>>>** H(**Ω**_{G(n)}) **≈>>** Ω_{m}v *{m**<<*ω}
Ω_{Ω+1} **>>>** H(**Ω**_{Ω}) **≈>>** Ω_{Ω}v
Ω_{G(Ω)} **>>>** H(**Ω**_{G(Ω)-}) **>>** Ω_{G(Ω)-}
Ω_{Ω.1} **>>>** H(**Ω**_{G(Ω)}) **>>** Ω_{G(Ω)}
Ω_{Ω.n1} **>>>** H(**Ω**_{G(Ω.n)}) **>>** Ω_{G(Ω.n)}

The indexes are names for `Ω`

and can be repeated to an index staircase as before,
expressed in an array function,
and extended to the most general recursive structure.

`Ω`_{Ω1} **>>>>** Ω_{H(Ω)} **>>** H(**Ω**_{G(Ω).v}) **>** H(**Ω**_{Ω.v}) **>>** Ω_{Ω.v}

**UNDER CONSTRUCTION @ June 2014**

### # Heaven's gate

Roadmap for the coming sections:

The indexes are names for `Ω`

and can be repeated to an index staircase and then an array,
extended to a structure that covers
`Ψ.u`

a 3rd general recursion.

The 2nd recursive array was the
`Ω.v`

jump staircase `ω`

._{v}

We can see each recursive array as attached to the `ω`

jump hub, or better perhaps the `1`

unit hub,
because `1`

is the primordial jump from
`0`

nothing.

Such recursive jump hub arrays can be counted, multiplied, jumped from, etc,
where the hub `ω`

or `1`

mimics the function of the `,`

separator in nested arrays and its further deep attachments.
In natural setting the character `,`

can be followed by many more (see Chris Bird),
leading to the general recursion over character signs
that is Gödel encoding, etcetera.

Then we can jump-jump to an even higher-higher recursion.
But if we keep going, can the jump mechanism ever be exhausted-exhausted,
like the 1st general recursion that couldn't reach infinity?

To stop counting is natural, and the other option is not to stop,
that is to jump to infinity. What logic would allow us a third option?
Not-not to stop could be something different!

This defines the first imfinity
(*i*ncluded *m*iddle)
for mathematical problems where the
excluded middle
of higher infinities cannot offer a solution.

(Brother Eg....bertus, why did you imp that far?)

The finite, infinite, imfinite, etc,
leads to an im-jump-recursive series of
`not-...`

stopables definable in male logic.
After that come the fim-jump-recursive
`fe-...`

male logics.
Not to mention the realms of *whatever*.

(To stop and talk constructively is always easier!)

` `