# The Evolution of Big Numbers

### in maths + the

# Revolution of Bigger Numbers

###
by **G**iga **G**erard

### Summary

$1. Foundations
$1.1. Counting numbers
To count an unnumbered collection of items,
single out one item and label it with the number 1 .
Then for each next item increment this counting number with a unit 1 ,
and continue until the whole set is counted.
Counting can be problematic in practice,
but in theory the elements |No|1..| of a set of size n
have a one-to-one correspondence
(paired, indexed, named or counted)
with the subset from 1 to n of the natural numbers.
Use no numbers twice, and leave no numbers uncounted,
so this subset is unique,
no matter in what order the elements are counted.
An empty set |{}| of size 0 has no elements,
counted with no unit one.
Counting without halt |1...|
equals the size omega ω of the set of natural numbers
(unlike counting without numbers).
The assumption the whole ω of this set exists,
is called the axiom of infinity.
Even an unbounded number like ω
can be counted upon in a next room, then counting
ω rooms, etcetera,
until another axiom knocks at the door...
Mathematical expressions are essentially lines of text,
compositions of signs in one discrete dimension,
associated 'ltr', in left to right direction.
Let uppercase letters from R to Z
stand for text variables in rules,
to express any permissible input sequence.
Variables are possibly empty, but only if the context allows that.
Write number variables or 'var' with a lowercase letter.
For an empty 'var', we can put or add 0 in its place.
In some array notations all entries must have value n>0
and empty positions and structures are removed first.
While our notation for "Big numbers" evolves,
smaller concepts appear first.
We like to index these earlier constructs on the left,
so that the structure of our array functions will expand to the right.
Our output is always a string of units 1 with length x ,
which can be a natural number,
some non-standard limit or a type of infinity.
Arrays contain rows of signs that can be repeated, nested, renested, etc.
These expanding structures equal the general recursive functions.
We see only the "pretty Big numbers",
most numbers are unpretty and remain hidden,
given that computational resources are final.
Take the universe mass of 2E93 standard kilogram photons,
with a star spangled lifespan of 5E64 Planck times.
In quantum superposition these represent 2^1E158 numbers,
so most numbers smaller than 2^^6 will never be expressed.
We can define a "Bigger number" or non-standard limit ψ ,
that lies right after any numbers expressible
within our standard array system for Big numbers,
given our physical resources.
If we input this initial unit ψ in our system,
the resulting output |ψ..|
is definitively topped by the next Bigger number ψ_1 with index 1 .
A succession of Bigger numbers ψ_k
can well be expressed within the same standard array structure.
Later such system revamps become enumerable in their own right.
All Bigger numbers are still finite,
but the same functionality applies to the ω -type
numbers in the higher infinite.
Just substitute the ordinal ω_k for ψ_k .
In general, if a mathematical construction can be repeated,
this construct in turn is countable by an index entry
within a larger system.
Note that numbers that enumerate sets,
function as members of sets.
This type of self-reference is a source of inconsistency,
when Gödel numbering statements about the whole of arithmetic.
Intuitively, to encode alphabets to maximally exploit signs
is a perilous method,
but does it help to get Big...?
$1.1.1. Unit addition
By addition of units one 1.. all the natural numbers are formed.
We adopt the decimal digits as constants for unitary numbers.
Constants from decimal a = 10
to unit notation. You can show more!
2 = 11
= 111
n = 1.. :n
We add two numbers a and b by putting them ab together.
A plus sign + can be used (instead of brackets)
to give precedence to other operations.
For example in a*1b = a+a*b we directly add 1b ,
but adding by plus + is postponed as usual.
Zero is nothing, which adds naturally at the right
n0 = n or left n = 0n by elimination.
On an empty 'var' place , we may put a zero 0 sign.
We use the negative unit - to decrement 1- = 0
from the right by convention,
so that n- subtracts 1 from non-empty n>0 .
$1.1.2. Rep notation
In Regular Expressions the quantifier X{k}
matches a character X or text group (X)
that is repeated at least :k times in a row.
We use the 'Regex' style repetition {k} for single signs alone.
In our 'Repex' notation we use dots and 'rep'
to select and repeat part of an expression.
Between the . dots ..
we select a sequence of signs,
that is to be repeated a total number of times
:n as specified in the 'rep'.
X.. :1 = X
X.. :1n = X..X :n
== X{n+1}
The selected item of the 'rep' :n
stands on the left side of the two .. dots,
or with n: on the right side,
or with :n: on both sides
and repeated from the outside to the inside of the expression.
Direction can be important.
During repetition an index i or j must be incremented.
Here we construct a multiplication *
of three numbers x_i step by step from the 'rep'.
1.*x_i.. :3 = 1.*x_i..*x_3 :2
= 1.*x_i..*x_2*x_3 :1
= 1*x_1*x_2*x_3
To append strictly 'ltr', keep track of the index value in the 'rep'.
Below we go from 0:4 to add 5 indexes.
n_i.. 0:4 = n_0.n_i.. 1:4
== n_0n_1n_2n_3.n_i.. 4:4
= n_0n_1n_2n_3n_4
The digits in a number are not added straight away;
that would be numerology.
As usual Arabic numbers are read 'rtl' with the smallest digit on the right.
"d_i.." p:0 => d_0.+d_i*10^i.. 1:p
Here each digit
0≤d_i<10 is multiplied * by a next power of ten from 1 to 10`p
step *10 and then this 'ltr' series is + added up.
#1.1.3. Nesting
Explain multiplication and powers as repeated addition,
or as the nesting of . numbers in .. the unit one. For example:
3 = 111
3^2 = 3*3 = |NoDec|333| = 111111111 = 9
3^3 = 3*3*3 = 9*3 = |999| = 27
3^4 = 27*3 = |(999)(999)(999)| = 81
3^5 = 81*3 = |(999999999)
(999999999)
(999999999)| = 243.
In general a^n1 = (a^n)*a
3^2 = 111+111+111 = 9
3^4 = 9^2 = 9*9 = 9.. :9 = 81
3^8 = 81^2 = (3^4).. :3^4 = 6561
3^2^4 = (3^8).. :3^8 = 43046721
3^2^5 = (3^16).. :3^16 = 1853020188851841.
In general a^2^n1 = (a^2^n)^2
#1.1.0. Renesting
#1.2. Array functions
#1.0.0. Ace system
#1.0.0. Bank system
#2. Beyond
The successor function σ gives the next natural number.
σ(0) = 1
σ(n) = n1
To get a natural number n ,
count every 1 and stop at n .
Or start from 0 and nest :n: successors within σ() .
Therefore sign σ equals unit 1 .
n = 1.. :n = σ(..) :n:
Notations in radix a
uniquely express every natural number n .
We make them rigorous by radix functions φ_α
with nested indices for places,
and further array structures for big numbers.
Faster increasing array functions φ_β will miss most numbers in between.
But all Big numbers can be matched by expansion of the φ_α structure.
#2.1. Infinity
Define the infinite unit omega ω as counting without halt.
To add up 1 or any finite positive number n
in an endless repetition gives ω .
ω = 1... = 1ω = nω
= n... = n.. :ω = n*ω
Cantor used omega ω to count the whole set of natural numbers,
and called this the lowest bound of infinity.
Infinite counting is right associative, we cannot increase ω
by finite addition or multiplication from the left.
Counting further on the right the following infinite ω...
are created in series, one upon the other.
ω < ω1 < ωn < ωω < ω*n < ω*ω
If we multiply n repeatedly without end,
this left associative power is stuck at ω .
Stronger: every increasing function φ over finite values n
will by recursion to infinite depth result in ω , but not more,
no matter the array structure X .
ω = 1.*n... = n^ω
= φ(..n..) :ω:
= φ(..n..,X_i) :ω:
To expand infinity we can input ω as a radix in function φ_α ,
or as add it in a faster function φ_β .
Increasing powers of ω on the right.
ω^n < ω^ω < ω^^n < ω^^ω
Every finite recursion results in a natural number,
less than ω = ω_0 infinity.
Similarly our next type of omega ω_1 is defined as the smallest infinity,
that is unreachable by general recursion over ω
in a finite function φ .
φ(n,X) < ω
φ(ω,X) < ω_1
By uploading omega ω in array function φ
this will expand to infinite lengths, dimensions and further structures,
full of infinite entries.
These array constructions are far more intricate, than the 2^ω
binary radix expansions to infinity for real numbers,
which we count off diagonally to ω over multiple dimensions.
And it is wrong to trick the power set of natural numbers down to 2^ω ,
though this set is less infinite than φ(ω,X) .
Enough ideas to drive Cantor mad.
"Real omega" ω_1 counts the whole set of general recursive functions.
All input expressions of array function φ_α
with entries smaller than some radix a are counted as ω_0 ,
because these represent the natural numbers in radix notation.
Same counts for its output as strings of ones 1..
But how do we count throughput expressions φ_α(10,b,X)
of our radix function?
These have a subtotal in output format in entry b ,
and a radix array X on the right,
with some entries a during evaluation,
that make X look like a radix |Dec|11| input array.
This pairs two finite subsets of natural numbers:
increasing ones versus decreasing radix representations.
Pure input first, pure output last.
Do you count them like Cantor counted
"odd and even" as ω at most,
the decimal radix arrays as ω*ω ,
and generally φ_α(a,X) as ω^3 in total...?
#2.2. Bigger
Introduce a non-standard unit psyche ψ ,
without immediate reference to sets.
This is the initial value of an indexing function Psycho Ψ ,
which can take over the form of any array system, and be appended to it.
This is the realm of the non-standard or "Bigger numbers".
We usually take ψ to be a natural number just larger
than the numbers expressible by a recursive function φ ,
given some physical resources or notational limitation.
But ψ can be any object with a property,
that is not yet represented in the current system,
and that lifts the system to a whole new level.
Our psyche can stand for infinite counting too.
Both Cantor's initial infinity ω or ω_0
and this infinite ψ or ψ_0 start at index 0 .
We then index infinity types in Psycho Ψ ,
so that every next ω_n
type will be inaccessible by recursions in φ
over all formerly indexed ω_[k<n] .
#2.2.1. Psyche
Given a function φ over natural numbers n
with an array structure X of recursive parameters.
Suppose a Bigger ψ cannot be expressed in this system,
because its size or complexity or type exceeds our notational resources.
Use a comparison < to put the Bigger numbers on the right.
φ(n,X) < ψ
This initial inaccessible is psyche ψ or ψ_0 with an empty 0 index.
When function φ is only vaguely defined,
and ψ is still accessible over the array horizon,
it doesn't make sense to compare ≤
to recursive operations over ψ , because it is less costly
to add them to the original φ .
By extending the old expression just marginally,
for example simply by incrementing φ(n,X1) its final entry,
this < accessible ψ explodes.
But in case ≤ improves on a strict notation or axiomatic bound,
like the countable infinity ω ,
we can increase upon ψ by ordinal arithmetic.
ψ ≤ ψ+1
ψ+k ≤ ψ+k1
ψ+φ(n,X) ≤ ψ+ψ
ψ*2 ≤ ψ*2+1
ψ*2+φ(n,X) ≤ ψ*3
ψ*m+φ(n,X) ≤ ψ*m1
ψ*φ(n,X) ≤ ψ*ψ
ψ^2*φ(n,X) ≤ ψ^3
ψ^φ(n,X) ≤ ψ^ψ
ψ^ψ^φ(n,X) ≤ ψ^^3
ψ^^φ(n,X) ≤ ψ^^ψ
ψ^{k}φ(n,X) ≤ ψ^{k}ψ
ψ^{φ(n,X)}ψ ≤ ψ^{ψ}ψ
Given a fuzzy limit of array function φ ,
working this out in ψ -ordinals is rather insignificant.
We can round off ψ ≈ ψ+1 obviously.
All finite operations a^{c}b with numbers ψ ,
but further φ(ψ,X) recursions too,
are merely Big compared to the Bigger jump to cardinality.
Now feed back ψ in the start entry of system φ ,
and repeat the < jump.
Next indexed cardinals ψ_k are guaranteed to be significantly Bigger.
φ(ψ,X) < ψ_1
φ(ψ_1,X) < ψ_2
φ(ψ_k,X) < ψ_k1
Express larger indices by operators, and further by Big φ output,
increasing over the natural numbers until we can go no further.
Then jump the index.
φ(ψ_[φ(n,X)],X) ≤ ψ_[φ(n,X)+1] < ψ_ψ
If ψ is an absolute limit number like ω ,
we can increase indices ordinally,
as worked out above for the numbers after ψ .
Consider this is entwined with increasing the
ordinal numbers themselves, involving the various indexed ψ_k .
Apply array functions to numbers and indices,
and the ordinal apparatus expands like crazy.
Soon we have deeper nested indices too.
Surely all this madness will raise more notational limit problems on φ .
But φ already owns a Big nested throughput structure,
we can reapply these resources, or else reconsider
the finite ψ -ordinals in ω -infinite function space.
For fuzzy φ or inaccessible ψ ,
we skip the ≤ almost equal comparisons in between,
and arrive at once <
at the next Bigger number in its cardinal second index.
φ(ψ_[φ(ψ,X)],X) < ψ_ψ_1
ψ_[φ(ψ_1,X)] < ψ_ψ_2
φ(ψ_ψ_2,X) ≤ ψ_[ψ_2+1] < ψ_ψ_3
ψ_ψ_k < ψ_[ψ_k1]
Expression forms are simplified towards the bottom,
but the complete top form cannot produce
significantly Bigger cardinal numbers. Check this...!
#2.2.1. Psycho
Create an indexing function Psycho Ψ
to express cardinals ψ_[._[.]] with nested indices.
After the initial Ψ(0) = ψ and single parameter Ψ(k) = ψ_k
its recursive continuation can go conform the same structure
as array functions φ .
For example, given radix function φ_α(b_0.,b_i..)
with ace a outside,
we express ψ_ψ_1 conform as Ψ_α(1,2) ,
while φ_α(1,2) adds up to aa1 , or as decimal number 21 .
Fill in, and evaluate without the Ψ_α() function signs:
b,1c = ψ(b),c
== ψ(..b..) :c1:
Fast function φ_β(a,1,1,1) with ace a
inside evaluates via φ_β(a,0,a1) to a*a1 ,
much like Ψ_β(ψ,1,1,1) to Psycho Ψ(..0..) :ψ_1:
which runs a sequence of indices ψ_[._[.]]
to cardinal ψ_1 depth.
In indexing function Ψ(Y) we don't add neighbouring units ψ ,
because each unit is to be indexed by the number on the right, in sequence.
So in entry b of Ψ we can see either ψ(X) or ψX or ψ_[X] .
But in Big functions φ we still add up Bigger numbers,
so there ψx is ψ+x and not indexed.
Abstract array X from expressions Ψ_α(ψ,X)
which upload the ψ constant.
Then expanding part X can never reach the 'rep' :ψ_1
of real index depth.
1,1,1 = ψ1,0,1 = ψ1,ψ
= ψ{ψ}ψ_1
b,c,d = ψ..b :ψ*d+c
0,0,0,1 = 0,0,ψ = ψ.. :ψ*ψ
1,1,1,1 = ψ{ψ}ψ1,0,ψ
= ψ..1 :ψ*ψ+ψ+1
Index function Ψ_α(ψ,b,Y) will append ψ -indices φ_α(ψ,0,Y) times,
with final index b .
Because we upload a constant ψ everywhere in Ψ_α
to reload recursions,
the index depth :ψ_1 can only be reached by jumping to comparison.
Ψ_α(Y) < Ψ(..) :ψ_1:
To obtain increasingly deeper indices, the "uploads"
should grow recursively for all array entries.
Our brand of Bird-Bowers array functions Ψ_β(ψ,Y)
lifts Psycho over the whole of the Bigger realm.
We skip the ≤ comparisons with φ(Ψ(Y),X)
and ψ -ordinal arithmetic.
Ψ_β(ψ,b) = Ψ_β(ψb) = ψ_b
Ψ_β(ψ,b,c1) = Ψ_β(ψ,ψb,c)
== Ψ_β(ψ,ψ{c}b) = Ψ_β(ψ{c1}b)
Bigger index depths inaccessible by ψ_a
follow soon in ψ_b .
Remember we don't add inside Psycho expressions,
each variable on the right indexes the unit on the left,
and that in series.
Ψ_β(ψ,1,,2) = Ψ_β(ψ,,ψ1)
= Ψ_β(ψ{ψ1}) = ψ_[..] :ψ_1:
Let's jump to the next cardinal construct.
Ψ_β(ψ,b,Y) < Ψ_β(ψ,b1,Y)
Ψ_β(ψ,Y) = Ψ_β(ψ,Y)(2)
Ψ_β(ψ,Y)(b) < Ψ_β(ψ)(b1)
Then...