Author:
Asamkhyeya dasa
Date:
9 april 2009
Motto:
Invito Patre Numeri Verso
From the days of Egyptian hieroglyphs to Indian decimals to 16th century exponentiation our ability to express numbers in a concise manner has evolved:
7555544444444333332222222111111 => 1048576 => 2^20
We have defined a super-exponential function bigE.
The Ackermann numbers are then expressed in bigE as
Ackermann(a) = E(a,a,a)
The formula C
for Conway's "chained→arrow→notation"
are comparable to those of bigE with one row of parameters.
Our objective is to create the fastest 'natural' algorithm for the construction of big numbers. The only hard criterion is reducibility.
Formula C
as well as bigE have some setbacks which can still be improved upon
– formula F
for example does a pretty good job.
This last function is definitely the fastest,
because higher parameters (on the right) have most effect,
and the substituted values v
(which sort the biggest effect) nibble off ones on the lower (left) end.
In the present article on bigI and bigU notations, instead of substituting parameters, we go one dimension deeper and substitute the entities 1
that make up those numbers.
Introduce the concepts of an entity one 1
and a natural number n
as a row of ones 1...
of length n
.
The negative entity
- = -1
can be used in operator functions
to create new sets of countable numbers such as fractions and algebraic complex numbers.
We won't go into that here, this article is about big natural numbers.
Define a meta-notation for repetition.
ABC...D [B#n]
(A
,C
and D
are optional and
B∉C
), explained:[B#n]
tells us to substitute BC...
in the preceding expression with a row of n
times the sequence B
, putting sequence C
in between
(B
being the first sequence B
left of the ellipsis).b;...;1 [b#111] = b;b;b;1 =
b;...1 [b;#111]
Add two numbers by placing series of ones next to each other.
Introduce the concept of substitution of entities
within natural numbers n
.
Entity ~
is a variable natural number variable that can change value each time it is used.
For ~
a certain set or bounds can be specified, mostly in the form
[~>n]
.
For example:
1*^{...}...1
[*#~>0 1*^{...}#k] = 1
Introduce the concept of a superator
;
that sits
between the parameters of operator functions such as
bigI.
Generally, to reduce an expression X;z1
of bigI to natural number, we repeatedly countdown
final parameters z1
by one,
and at each countdown substitute all entities 1
within the parameters of X
with a joker J^{k}
,
which is based on the former largest number X;z
and on the dimensionality of the expression.
We mention two variations for initial jokers J
here, and apply the second variation in following formula.
J = J^{0}
can be derived from an expression
X;z
simply by removing all its superators,
leaving only ones.
Though this looks contrived, substitutions are possible without separate calculations (or inserting parentheses).
J = J^{0} = (X;z)
is reduced to natural number before substitution (or remains in parentheses until later).
This J
is a 'one step smaller' number for expressions of a single parameter row.Maximal general formula bigU
Maximal example formula bigU
Maximal example expressions bigU
We describe four variations of joker substitution in bigI here, and apply the second.
Variations III. and IV. work with direct substitution –
replacing entities with an unresolved subsentence
J^{k}
.
J^{k}
can be reduced to natural number before substitution, and then simply added.J^{k}
are reduced to natural number (in theory), followed by superators
;...[;#k]
of length k
in between.J^{k}
may remain an array of parameters J
,
followed by superators
;...[;#k]
of length k
in between.(J^{k}
and a virtual closing parenthesis at the end:)
Enter the second dimension of bigI's parameter array
and expand previous parameter rows
by replacing entities 1
in previous rows subsequently
by J^{1}
,
which represents a row of J
parameters J
.
Superator operations are resolved from right to left.
We'll evaluate expressions by rule of maximal precedence,
where right operands separately address each entity in every left operand (not in parentheses) up to the start.
Follows the formula for bigI up to the second dimension, separately substituting every parameter.
Maximal general formula bigU
Maximal example formula bigU
We formulate two variations of joker array construction by direct substitution here, and use the first for bigI.
(Natural number substitution of previous jokers replaces
:=
by
=
in the formula below,
but that would slow down the algorithm.)
J^{n}
are n
-dimensional arrays, where all inner dimension lengths are equal to
J
, creating a giant dimension box.
J^{m1} := J^{m};^{...}...
[;#m1 J^{m}#J]
J^{n}
are n
-dimensional arrays,
where dimension lengths are repeated by the dimension's value.
Their shape gets elongated in the higher dimensions
— like a very long brush stroke.
J^{m1} := J^{m};^{...}...
[;#m1 J^{m}#J^{m}]
As an example we enter the third dimension of bigI and expand previous parameters by replacing every entity 1
subsequently by J^{11}
,
which represents a square of J×J
parameters J
.
Choosing substitution variation II. or III. above, we use jokers
J^{k}
to substitute entities 1
and
superators ;...[;#k]
of length k
are put in between.
The principle applied here is to replace the virtual superators
;...[;#0]
of length 0
in between entities.
Then also every superator
;...[;#m 0<m<k]
in between parameters,
should be replaced by a superator of the appropriate maximal length k
.
Abiding by the principle of substitution variation I. we could have kept the existing superators as is.
Evaluation definition –
Move right to left, count down parameter z1
and subdivide expression bigI into sections
S_{i}
,
where S_{k}
in
X;...S_{k};...Y;z
[;#m ;#k1 m>k1]
is the section between the expression's rightmost superator
;...[;#k1]
on the right
and the rightmost superator
;...[;#m m>k1]
(if any) on the left. Then for all subscripts
S_{x} in X [x>k]
and for all subscripts
S_{y} in Y [y<k]
.
Within section S_{k}
use jokers J^{k}
(as defined above for dimensions and below for types) to substitute entities 1
and (optionally) use superators ;...[;#k]
to append and to substitute existing posterior superators ;...[;#m m<k]
.
This defines the evaluation of expressions bigI
in all dimensions and for all types.
Maximal general formula bigU
Evaluation definition –
Move right to left, count down parameter z1
and subdivide expression bigU into sections
S_{i}
,
where S_{k}
in
X;^{...}S_{k};^{...}Y;z
[;#m ;#k1 m>k1]
is the section between the expression's rightmost superator
;^{...}[;#k1]
on the right
and the rightmost superator
;^{...}[;#m m>k1]
(if any) on the left. Then for all subscripts
S_{x}
in^{ }X [x>k]
and for all subscripts
S_{y}
in^{ }Y [y<k]
.
Within section S_{k}
use vana V^{k}
(as defined below for 0-type bigU dimensions and separately for n-types) to substitute entities 1
.
NOTE: The bigI evaluation rule to append superators and substitute existing posterior superators feels a bit contrived, we won't use it here. The advantage of introducing superators inbetween would be small compared to the number of such superators in the vana.
Trivial cases:
X;^{...}[;#n] = X
and single ones: ;^{...}1;^{...}...1
[;#p ;#~>0 1;^{...}#k] = 1
This^{ }defines the evaluation of expressions bigU
in all dimensions and for all types.
Substitution definition – for bigU expressions
u = a;X
Dimensional vana are constructed with natural number substitution (instead of the direct substitution we used before, when previous Joker dimensions where directly inserted as character sequences).
Initial vana:
u = 11X
=>
v = 1X
u = 1;^{...}...;b1;X
[;#~>0 1;^{...}#k1]
=>
v = 1;^{...}...;b1;b;X
[;#~>0 1;^{...}#k]
Next vana:
V^{m1} = V^{m};^{...}...
[;#m1 V^{m}#V^{m}]
and V^{0} = v
Maximal example formula bigU
Preceding superators
;...[;#p]
create extradimensional bigI functions of type p
,
which are constructed similarly to the typeless bigI above.
Apply the following joker construction principles to substitution variations I. or II. or IV. (we apply II.).
For variation III. to be possible without separate calculations (or inserting parentheses) the substitution jokers
J^{n}
must remain without prefixed type-superators.
;^{...}1X;z1
[;#p]
has an initial joker
J = J^{0} = ;^{...}1X;z
[;#p]
J^{n} = ;^{...}J^{m1}
[;#p]
with each
J^{m1} := J^{m};^{...}...
[;#m1 J^{m}#J m<n]
These jokers are to be substituted into bigI expressions, as shown in type-reduction and the general two parameter case.
The evaluation definition in the previous chapter explains the rules to reduce all typed bigI expressions to natural number.
Maximal general formula bigU
Substitution definition – for bigU expressions
u = ;^{...}a;X
[;#p1]
Initial vana:
u = ;^{...}11X
[;#p1]
=>
v = V^{0} = ;^{...}1X
[;#p1]
u = ;^{...}1;^{...}...;b1;X
[;#p1 ;#~>0 1;^{...}#k1]
=>
v = ;^{...}1;^{...}...;b1;b;X
[;#p1 ;#~>0 1;^{...}#k]
Next vana:
V^{m1} = ;^{...}V^{m};^{...}...
[;#p ;#V^{m} V^{m}#V^{m}]
Maximal example formula bigU
The bigI and bigU numbers in the previous chapters are written using only two characters.
The algorithms we've used to reduce them to single character 1...
format are about the fastest we can get given certain esthetic constraints such as algorithmic simplicity.
The whole digit range of binary number notation is covered, introducing the concepts of parameter rows and dimensions and types to illustrate every possible ordering of the number character 1
and its superator ;
To move one step further and "jump out of the box, into the ocean", we need to introduce a third mathematical character. This new character would typically redefine the strength of the previous two characters, depending on their mutual position in the sequence, and thereby increase the speed of the total algorithm. And similarly to ;...
(dimensions and types), multiples of this new character (again depending on position) would increase inherent character strength dramatically.
It would take a lot of effort on a mathematician's part to exploit all the possibilities an extra character gives maximally. In combination with previous characters – how many fundamentally different character sequences are there? What is their natural order? How do we define these sequences to produce the biggest numbers? How do we keep it simple and continue in a certain style – the natural expansion of bigI or bigU (or any other two character algorithm)? Is such a basic style systematically definable or is it a question of trial and error?
After 3 characters comes a 4th. Of course any number of extra characters can be introduced to define faster algorithms to create bigger countable numbers. And every next character will in principle count (or boost the length of) series of previous characters a magnitude faster than previous characters can (applied to themselves).
But you can't have a character to express the length of your list of characters directly – such a character counter cannot be designated with a character from the same character list – logically it would have to qualify as a meta-character. From then on you're talking in a higher order language.
Next thing you're introducing meta-characters to count previous meta-characters, creating levels of meta-characters which you can count with a meta-level counter, for which you need... a meta-meta character. This sequence of meta-meta-metas never stops, and the order of your language is lost in oblivion.
Imagine a meta-function of bigX which tells us what the biggest number is we can express in bigX (eg. bigU) with a given number of places and characters. Such a maximum function may remind you of the
busy beaver,
which is a Turing machine that starts on an empty tape, runs as long as possible, and eventually halts. The maximal number of characters a Turing machine in a certain n
-state can theoretically write on tape is called its busy beaver number (a function of n
). Those numbers have been proved to be non-computable.
The biggest number expressible in bigU with
2
mathematical characters
on a+3
places is
;...111 [;#a]
,
this is proven up to extradimensional vana in next chapter's box in case
u_{5}
(note that wana require a 1
digit less).
Following this example we can define what the maximum numbers expressible in bigU with arbitrary numbers of characters look like, even though we still haven't got a clue what the new characters do and what the best algorithms are to reduce such expressions (and whether m
-character algorithms can be proved to be systematically definable).
It feels a constructive step to state beforehand, that in a bigU notation deploying m
characters fully and the latest character number m
written as μ_{m}
,
the maximum number expressible on a111
places
is μ_{m}...111
[μ_{m}#a]
.
You might like to drop the "number of characters" parameter and make your max-functions solely dependent on the "number of places", simply because you like single parameter functions. There's a binary workaround for this. We can express our mathematical alphabet in binary bits, similar to a bit-expression in a computer, where m=2^7
ASCII characters can be expressed in n=7
bits.
Suppose the successive versions of bigU always work with binary alphabets and you can employ any number of mathematical characters you like, then the number of characters m
we'd best use to create the biggest numbers are
powers of two m=2^n
(else we have to leave character bits undefined).
Now, because there's always a trade-off between character bits and places, less places means there is not much room for alphabets that write advanced characters with a lot of bits (if you want big numbers).
n=0 | m=1 | 111 | maximum number for a<4 |
n=1 | m=2 | (000)0111 | max for 3<a<8 |
n=11 | 2<m<5 | (00)00101010 | max for 7<a<12 |
n=111 | 4<m<9 | 000100100100 | max for 11<a<16 |
n>11 | 2^(n-1)<m<2^n+1 | 0^{...}10^{...}...[0#n 0#n- 10^{...}#111] | max for n*4-1<a<(n+1)*4 |
Because of such binary trade-offs, a maximum function of bigX can be a function solely of the available number of places.
When bigX
enters a new cycle, it is succeeded by a function bigXX
whose power is comparable to the maximum functions described above. After the first parameter every bigXX
will get a second, counting the first, etc.
Parameters, rows, dimensions, types and optionally characters beyond two – if the corresponding algorithms can be systematically defined for every next character – all these constructs are reducible by the same algorithmic model that applies to the original function bigX
.
When this next cycle is completed a new maximum function bigXXX
of bigXX
follows the same path, etc. Of course, the large number of characters implied by a character counting cycle are not required to describe the cycling model itself.
Further on we start to count the number of X
's in bigX...[X#a]
, as the primary cycles for a cycle function of bigX, a meta-meta function so to speak, which again is reducible by the same algorithmic blueprint we originally defined for bigX
.
Are the functions counted by X
's the first meta-level functions and cycli the second (meta-meta), many more meta-level functions will follow. And irrespective if all those different levels can be represented as parameters in a comprehensive single bigX-style meta-level counting function, all levels can at least be counted, so the numbers they create will be bigger than ever.
Similar cycli lie at the heart of what the introduction of a new character means (in fact we cycled from one parameter to multiple dimensions before). Only if a 3-character cycle mechanism is exhausted fully, a 4-th character cycle comes into question. And only if (the construction of algorithms for cycling) every next character is defined, there can be meta-cycling over the characters as a whole. And after that meta-meta-cycling and the counting of metas, it never stops...
For an algorithm there are
principles and disciples.
Principles are the broad concepts that form algorithms,
and disciples are number expressions that can be reduced by those algorithms.
Because anything in nature can be represented fully in a binary series and eventually translated to a row of ones, everyone is a disciple.
More and deeper principles allow us to create bigger numbers. The way to invent principles is just to start and see what happens. How about the principle that everything we encounter twice is countable? It's a question of recognizing the one and the two.
×
).
Somebody else repeated the repetitions themselves
(exponentiation ^
).
Later it appeared those levels of repetition are countable
(super-exponentiation *...
).E(a,b,c)
,
where the 3d parameter counts the number of operators. Inspired by this Conway introduced a function where the parameter row could go on indefinitely. Then some big number enthusiasts realised the length of parameter rows is countable inside a multidimensional parameter array.;
to separate dimensions and took it as just a 2nd character after which come many more... But first I had to fill my super-binary notation to the brim with extradimensional types that expand (count) dimensions (superators).
There are four principles at work in the definition of algorithms that write big numbers. Except for a further elaboration on the 4th big principle – reminiscent of Rinzai's guest sees guest – we've met them before.
1
, -
(minus one) or
ω
(initial infinity).;
or a character counter or meta-cycle counterz
is reduced from 1
.v
,
which is a Guest expression derived directly from (and smaller than) the Host, by
counting down a parameter so that reducibility is assured.
"Guest invitation" in bigU is maximal, because its initial vana counts down the most insignificant Host parameter by 1
.V^{m}
can be made multidimensional or extradimensional, etc.
so long as their substitution position in the Host expression preserves reducibility.My experimental wana nesting add-ons are not as fast as character introduction by maximum cycli (see previous chapter), and perhaps overly complicated (see example box).
Wana nesting examples in bigU
One cannot count up to infinity, but
Georg Cantor in 1874
invented two different types of infinity: a countable infinity
(counting all natural numbers), which is bigger than any countable number,
and an uncountable infinity (counting all real numbers),
which is bigger than any number that counts "deeper than countable" numbers.
Cantor couldn't find the connection between these two infinities by counting upwards with
his countable infinity
ω
(omega).
So far all the numbers we've created with our algorithms for big numbers and 1
are countable and smaller than infinity.
Only by postulating a first uncountable number
ω
and using it as an entity to seed a super-exponential function bigE
or a super-factorial function bigU,
we can count further into the infinite realm,
the same old way Cantor progressed with his ordinal numbers.
Though Cantor showed his famous
diagonal argument
in radix r=2
, a special case of
E(r,ω,11)
,
the positioning of numbers inbetween earlier ones can be much more intricate than Cantor suggested, if we'd exploit the whole parameter range of a big number algorithm.
Deeper and down the reals, the cardinality of the continuum must be an order higher than that of the discrete infinite numbers we create by means of the uncountable entity
ω
(and countable entities such as
1
and -
).
The only way to make Cantor's uncountable infinity
countable is by postulating a higher type of infinity – an ordering of heavens so to speak.
Starting from the countable finity
1=ω_{0}
and the countable infinity
ω=ω_{1}
,
the next-countable infinity
ω_{11}
can be as big as the set
ℜ
of ω-deep numbers created by bigE or by any bigX...
(inverse) iteration of any number of finite or countably infinite entities.
These and the unavoidable next 'Cantor-uncountable' ω_{n}
infinities we can count with infinite number functions of general type
bigX_{Ω} and induction.
For example:
This last expression models the first row of parameters of bigU_{Ω} after bigU.
We can continue that model with the same algorithms for dimensions, types and cycli as for bigU, reducing the bigU_{Ω}
parameter array to a natural number
n
as usual and finally to an infinity
ω_{n}
,
in an effort to write the U_{Ω} travel-guide for the realm of meta-countable infinities.
When we wake up the next morning the U-subscript
Ω
itself
has started franchising the business model of bigU:
As the following parameters of the U-subscripted function
Ω
pass through dimensions and cycles, a new infinite number can be postulated that lies beyond its reach. This next order of infinity has its own generator function, which means in effect that Ω
will be Ω
-subscripted itself.
Counting Ω
-subscript depths for higher order infinity generator functions has its appeal, but don't think bigX-franchising will end with an infinite number that lies beyond the reach of
Ω
-subscription.
That's just a next step "out of the box and into the ocean".
But maybe, if God created 1
from the void and Cantor did it for natural numbers,
we are now in a position to propose an infinite number beyond compare – unreachable by any algorithm of any number generator X
and infinity generator Ω
.
It lies wholly beyond the methods of induction on ones and omegas and of such induction on models, and is therefore beyond compare.
Perhaps you'd like to call that number
ψ
(psi), I don't mind about names.
After Ψ(0)=0
,
Ψ(1)=ψ
could be the first zero reincarnate, and
Ψ(ψ)=ψ_{ψ}
a reincarnation of reincarnations –
the "biggest number" of our time, because I halted.
But what if the finest mathematicians of all time would reincarnate in a big bang bubble with infinite resources and the sole purpose of inventing big numbers, when would they halt? Call that number St. Peter's Subway.