## Ψ.2.Up to the Ackermann numbers

### # 2.2.Inverses and infinities

#### §2.2.1.Unit `-`

Notate new style negative integers as repetitions `-*n = -.. {-#n}` of inverse units.
The inverse unit `-` and its complex root `î` = i can be defined as follows in star context.

• -1 {0*} = 0 (successor is zero)
• -*- = -**11 = 1 (square)
• (a*b)(a*c) = a*(bc) (left distributive law)
• 1- {0*} = (-*-)(-*1) = -*(-1) = -*0 = -.. {-#0} = 0 (add right)
• î*î = -

When we allow negative integers as values of iterators, arithmetic is already enriched with division, square roots, etc. There are many iteration operators, so the mathematics of inverse functions is an abundant topic.
The elementary inverse sets comprise the negative, the rational and the algebraic complex numbers.

a = ab(b*-) => `{set-I}`
a = (aI*b**-)*b => `{set-II}`
a = (aII**b**-)**b => `{set-III}`

Even though their real world approximation might well require infinite series, inverse numbers can be represented exclusively by countable units {1,-,*} and in this (notational) sense all inverse numbers are countable numbers.

John Napier
Edinburgh 1616

The two inversions of superpowers can be represented by a multiple division sign `/..` for super-division (division, roots and super-roots) and by a new binary operator `£..` for super-logarithms, functioning as you would expect from conventional logarithms.

• a = (a/..b)*..b {/#c *#c}
= (a*..b)/..b {*#c /#c}
• a^..(a£..b) {^#c £#c} = b
with a£b = alog(b) = log(b)/log(a)

A super-modulo operator `%..` is helpful too, but you won't see that many inversion signs in this article. The int function yields the integer part of a number, so int(2.7) = 2 and int(-3/4) = 0.

a%b = a - int(a/b)×b
a%..b {%#c1} = a - int(a/..b)^..b {/#c1 ^#c}
so (a*..b)%..b {*#c %#c} = 0

Beyond exponentiation little is known about the super-roots `///` and super-logarithms `££` of superpower operation `***` and beyond. We can speculate that every superpower creates new sets of inverse numbers by combining earlier sets with the inverse unit `-` in various equations.
A mathematician who can pave the way for such inverse superpowers surely has Napier's bones.

#### §2.2.2.Unit `ω`

Georg Cantor
Berlin 1867

The first number that cannot be reached by finite counting is the natural infinity `ω` called omega. Georg Cantor invented omega to count (or name) the denumerable infinite set of all natural numbers.
By definition the unit `ω` is larger than any number expressible by recursion over units `1..`

1... {1#ω} = ω   where  1.. {#n} < ω < ω1

Starting from the above order relation on omega and counting further with his infinite numbers (ordinals), Cantor travelled into the realm of countable infinity (Cantor's paradise) and never came back…
We'll declare `ω` to be the first unit of infinity and apply `ω` in place of `1` to express much Bigger infinite numbers.

ω1... {1#ω} = ωω = ω+ω
ω... {ω#ω} = ω*ω
ω*... {ω#ω} = ω**ω
ω**... {ω#ω} = ω***ω = ε0
ω*.. ... {*#ω ω#ω} <~ Ack_ψ(ω)

Only when our operatorial expressions fail to reach higher a second infinity `ω2` comes im Frage.
So an infinitorial function bigOmega can be defined, where `Ω(1) = ω` and `Ω(n) = ωn` and we can see that the road from `Ω(0) = 1` to for example `Ω(1,1) = ωω` never ends, but does have a beginning.
It's the beginning that's special – and that is why our natural reality is probably virtual, some game designed higher up – and primitive mathematics is actually real and most important… ;–)

Concerning the domain and range of limits for functions of superpowers as `b` tends to infinity – Euler's thematic `ê` in the minimum and maximum of `***` captures our imagination and helps us derive the power twins.

u = a*b   {b↑ω} => a↓0 => u↓0
u = a**b  {b↑ω} => - ≤ a ≤ 1 => u*(u*u)- = 0
u = a***b {b↑ω} => 0 ≤ a ≤ ê^ê^- => ê^- ≤ u ≤ ê
a = ê**ê*- = 0.0659.. => u = ê**- = 0.367..
a = ê**ê**- = 1.444.. => u = ê = 2.718281..

u = (n^n^-)^^b  {b↑ω n>ê} <=> n^n^- = u^u^- <=> n^u = u^n
p^(p+d) = (p+d)^p  {d↓0} <=> p =↑ ê
(1+a^-)^a {a↑ω} = b*(b!**b**-) {b↑ω} = ê

An exciting problem is whether the inverse values of function counter `c`` ` naturally classify recursive algorithms. The rational number of stars `a*...b` {*#1/2} for instance should be the operation halfway between addition and multiplication, but what does that` ` mean?