van NovaLoka

Neuropol 0

Counting Numbers

Waking from the void, which is nothing, you can see something, a thing, and call it one and write: 1

You can count a number of things 111... [1#n] and write this as a (usually decimal) number n
For example: 1111 ~ 4

Number Operations

If you have counted a certain number a, you can count some more b, which is an addition a+b
For example: 111 11 ~ 3+2 = 5

When you count the number of times b you add a certain number a, this is a multiplication a*b
For example: 3*2 = 3+3 = 6

You can count the number of times b you multiply a number a, which is raising to a power a^b
For example: 3^2 = 3*3 = 3+3+3 = 9

Or count the number of times b you raise a power a, written with a double arrowhead as a^^b
For example: 3^^2 = 3^3 = 3*3*3 = 27

And so on... you can raise superpowers, and write those (with extra arrowheads) as a^^^...b
For example: 3^^^2 = 3^^3 = 3^(3^3) = 3^27 = 7625597484987

Operator Function bigO

When operator arrowheads are recognized as countable, you can define an operator function O() like so:

O(a) = a
O(a,b,0) = O(a,b) = a+b
O(a,b,1) = a*b
O(a,b,2) = a^b
O(a,b,c) = a^^...b [^#c-1]
         = O(a,O(a,...O(a,a,c-1)...,c-1),c-1) [a#b]

For example: O(2,3,4) = O(2,4,3) = O(2,16,2) = 65536
O(3,2,5) = O(3,3,4) = O(3,7625597484987,3) = 3^^7625597484987

bigO's Parameters

All next parameters in the operator function bigO can be interpreted as substituting the numbers in bigO's parameter list in the style of the Ackermann numbers, like so:

O(a,b,c,0) = O(a,b,c)
O(a,b,c,1) = O(O(a,a,a),O(b,b,b),O(c,c,c))
O(a,b,c,d) = O(O(a,a,a,d-1),O(b,b,b,d-1),O(c,c,c,d-1),d-1)

Om(a1,...,am-1,0) = Om(a1,...,am-1)
Om(a1,...,am-1,z) = Om(Om(a1,...,a1,z-1),...,Om(am-1,...,am-1,z-1),z-1)

Or perhaps you'd prefer a different kind of substitution in the style of Conway & Guy's chained arrow notation, which also results in terribly big numbers. Here all parameter entries receive the same chained value. As always any ending zeros should be removed from the list.

O(a,b,c,1) = O(O(a,b,c),O(a,b,c),O(a,b,c))
O(a,b,c,d) = O(O(a,b,c,d-1),O(a,b,c,d-1),O(a,b,c,d-1),d-1)

Om(a1,..,am-1,z) = Om(Om(a1,..,am-1,z-1),..,Om(a1,..,am-1,z-1),z-1)

Which substitution you choose is not important yet, what matters is that none of the resulting parameter lists (of the top level as well as the nested bigO functions) get any larger. Substitution rules should abide by this principle of reducibility.

Parameter Dimensions

As parameters appear to be countable too, you can start a new line of parameters after a dimension-1 separator ; that signifies the end of a row within a square array of parameter entries. The function that reduces a bigO square to a bigO line can be Ackermann-style defined by:

Om,2(a1,...,am; 1) = Om(Oa1(a1,...,a1),...,Oam(am,...,am))

Better still, your bigO square can be chained-style defined. Because all entries get the same chained value X it is possible to expand the top level parameter list of all previous rows to a size _X. Thus in further dimensions the numbers created with chained-style bigO are superior to Ackermann-style bigO. From now on we'll only develop formulas for Conway & Guy's chained-style bigO (these are somewhat simpler too :o)

Om,2(a1,..,am; 1) = OOm(a1,..,am)(Om(a1,..,am),..,Om(a1,..,am))

Om,s(a1,1,..,aj,1;...;a1,s,..,ak,s,z) =
     OX,s(X,..,X;...;X,..,X,z-1) &
     X = Om,s(a1,1,..,aj,1;...;a1,s,..,ak,s,z-1)

Subscripts are coefficients that are useful to keep track of dimension sizes, they add to the legibility of the parameter variables that follow in bigO, but are not numerically significant; whereas superscripts are essential coefficients that define the type of the sign that follows. We write superscript type-coefficients in front of the sign they apply to (to avoid confusion with the conventional way of writing omega and epsilon constructs).
So ,=:0; is the usual dimension-0 separator,
and ;=:1; is the dimension-1 separator.
With ;;=:2; as dimension-2 separator the cubic bigO defines a 3-dimensional parameter list:

Os1,s2,s3(a1,1,1,....ak1,k2,s3,z) =
     OX,X,s3(X,....X,z-1) &

     X = Os1,s2,s3(a1,1,1,....ak1,k2,s3,z-1)

Chained-style bigO defined for m multiple dimensions with dimension-n separators :n; (collapsing z=0 and empty dimensions) the general formula is:

Os1,..,sm-1,sm(a1,..,1,.:.ak,..,sm,z) =
     OX,..,X,sm(X,.:.X,z-1) &

     X = Os1,..,sm(a1,..,1,.:.ak,..,sm,z-1)

In the above dimension formula the m in the operator subscript _sm is the dimension of the box. Before entering the entries of a next dimension a higher separator :n; must be put in place. Apparently separators are countable too, whilst :m-1; is the highest separator necessary in the above dimension box.

Extra-dimensional Nesting

What lies beyond a multi-dimensional box?
Well... All next parameters would have to increase the dimensions of the box as well as the sizes of all its sides to the same X. Another way to look at this is that all parameters in the box are themselves nested dimension boxes: each array entry holding a number that can only be (humanly) expressed by a multi-dimensional array. Then parameters can create parameter arrays nested to ever deeper depths expressible only by ever deeper levels of nesting.

To make numbers grow 'out of the box' a new type of separator must be introduced; a semicolon with two values :0,1; which separates the dimensional realm from the extra-dimensional.
When the first parameter after an extra-dimensional separator is 1, it will take the number X the preceding box amounts to, and substitute the whole box at once by a new X-box – a box with dimension _X and all sizes _X and each entry X.

Os1,..,sm;1(a1,..,1,.:.ak,..,sm:0,1;z) =
     OX1,..,XX;1(X,.:.X:0,1;z-1) &

     Xn = X = Os1,..,sm;1(a1,..,1,.:.ak,..,sm:0,1;z-1)

After :0,1; a bulk of parameters separated by the usual :n; dimensional separators may follow in bigO's parameter list. Then another :0,1; may appear, and the preceding bulk will be treated as a second X-box where dimensions are expanded directly (to a tandem total X). After a while a third extra-dimensional separator appears, a fourth, etc.
The next type of separator :1,1; counts the previous type :0,1; and tells us there are X of them, each with a dimensional X-box inbetween.
Following the same routine :2,1; counts X :1,1; separators and moreover puts the number of smaller :0,1; and all the X-boxes inbetween to X.
Generally in the separator succession :   type :n,1; counts X :n-1,1; type separators, each with X :n-2,1; types inbetween, each with X :n-3,1; types inbetween, etc... up to (a total of X^n of) the smallest extra-dimensional separators :0,1; with X-boxes nested inbetween.
Increasing the second separator parameter to :0,2; means you count X preceding type :X,1; separators before (with every z countdown that happens thereafter!) and also nest an X number of smaller sized separator types :X-n,1; as described generally above as a separator succession.
Then :a,2; nests a separator succession of X :a-n,2; types inbetween, up to (a total of X^a) :0,2; that each nest X type :X,1; separators, etc. up to the X-boxes.
More generally the :0,b; type separators count X :X,b-1; types with a nested separator succession as usual, and the :a,b; type separators count X :a-1,b; types with a nested separator succession as usual. A third separator parameter :a,b,c; could be put to work, etc...

In bigO at z countdown every separator ; with parameter list of length _n and ^c_n>0 follows just one rule :
:c1,..,cj,ck,..,cn; type separators (where ^c_k is the first ^c_i>0 in the list), nest X :X,..,X,ck-1,..,cn; types inbetween with separator succession
(where X is the number bigO amounts to).

A square array of separator parameters – where a parameter row can be expanded to X columns – is thinkable, as are further dimensions...
After analogy with bigO all preceding dimensions of a separator parameter array are set (by z countdown) to size X, which is multi-dimensional separator succession.
Then extra-dimensional separator succession follows, with a full blown second level of separators, like so:

Book of records number: O(20080501:20080501:20080501,20080524;20080501;20080501)

In our quest for bigger numbers higher levels of separators are a real boon. These levels are countable, thus far we've counted ², not much...
Suppose we count ^X levels, and on each level ⁿ there's a row of parameters of size ^X filled with numbers ^X separated by ^; of level ⁿ⁺¹
Suppose we call this thing a separator X-succession and it seems the second thing after the bigO X-box, then can one count these things??

Cycles and Characters

The answer is "yes" we should count these things. It works like this:
You define a 'countable separator' as ; with a superscript which has our new separator X-succession as explained above (all is ^X).
Now to go down to the bigO level of 'countable numbers' you must count all the way down to the smallest separator , each time placing X times the preceding separator inbetween. Then when you persevere for X centuries you'll arrive at numbers; substitute all those by X and your X-succession-box is ready!
Of course to get a number (eg. as a series of 111...) from this box you must ardently perform bigO z countdown (that'll keep you busy till Jesus comes back).

The point I'd like to make is: only now do we need a new character, a next generation separator.
The separator X-succession began with a parameter list of size ^X, then each separator again got a parameter list of size ^X.
At level ⁿ there were ^{X^n} separators placed, at the highest level ^{X^X}. Actually this forms a multi-dimensional separator-box of size ^{X^X}, a next generation X-box.
It was only after the invention of the X-box that we started doing separator arithmetic. Just like (at an earlier date) the introduction of the separator in bigO makes number arithmetic possible.

If you count your numbers as 111... you already use a separator, the most primitive, a   space inbetween each 1. Call this a separator without a superscript. Then you can start separating numbers by , which is shorthand for the separator :; inbetween parameters; and ; is shorthand for :1; the separator at the end of a parameter list.
It is philosophically interesting to note, that any number n=111... has (at least) n-1spaces inbetween, but space separators are not countable: any amount will do.
So are spaces separators? Yes and No. Do they count as characters? Perhaps as the 0-char.

Then see within bigO we had numbers, basically defined by the 1-char 1 (our decimal system is just a shorthand and really not of much use to create big numbers). And also we had a separator 2-char ; to which we assigned different roles using numbers. And our numbers got BIG.
Now a third separator is needed, the 3-char : (I've been using it without a preceding superscript thus far). Which creates ever more combinations together with the previous chars.
First of all : helps to get rid of superscripts;. If you use the official way of writing :; (instead of ,) then the whole parameter list can be reduced (multiple dimensions to 1 dimension) to a line.

A truly new application of : (or in char-notation #3, officially #111) is the double :: (or #4#1#3, officially #1111#1#111) that is the separator to end a separator X-succession, so following numbers can increase the levels of separators ; recursively by X.
Here's for example a new...

Book of records number: eh... to be continued eh... work in progress

So you can count operator parameter list to operator subscript cycles or alternatively the number of different separator characters :a,b;
When a number n of such chars can only be expressed by a number that is itself a cycle number of bigO you've reached a new paradigm.
Operator subscripts fall short of expressing this, and the need for meta-separator characters arises, because you run (by definition) out of ordinary separator chars.

Operator Cycles

Meta-separator character nesting can best be tackled by using a next operator Q as in the example above.
This bigQ is defined after analogy with bigO:

Q(a,b) = O(a:O(a:O(...:a;...);a);a)  [O#b & a#2*b+1]
Q(a,2,1) = Q(a,a)
Q(a,b,1) = Q(a,Q(a,...Q(a,a)))  [Q#b-1 & a#b]
Q(a,b,c) = Q(a,Q(a,...Q(a,a,c-1)...,c-1),c-1)  [Q#b-1 & a#b]
Q(a,b,c,d) = Q(Q(a,b,c,d-1),Q(a,b,c,d-1),Q(a,b,c,d-1),d-1)
etc.  substitute Q for O in formula for chained bigO

After this we may recognize operator-character cycles O,Q,2Q,...,nQ, until n is nested as in nQQ whose nesting depth can be expressed (counted) by a second operator counter (a superscript).

After that we suppose the number of different superscripts for bigQ are countable and an analogy with :n; nesting in bigO becomes clear. A truly next operator character comes in need (in essence O=0Q).

Not so much later meta-meta-...levels of operator cycles can themselves become countable hierarchies.
And after that meta-hierarchies of hierarchies for operator-character cycles of separators for nested dimensions of parameters for chained bigO numbers come into play. And the meta-upon-meta play never ends, does it?

Paradigms and Paradoxes

How many method paradigms are there? Are they countable? Can infinity be reached?
The chapter headings on this webpage show some major paradigm shifts we've gone through on our quest for producing big numbers, and the last chapter hinted at some more. We've entered the realm of philosophy.

Now you might like to make progress by counting paradigms and beforehand state something like: "My big number lies at Paradigm₇₇₇".
Hereby you've created a paradox, for this paradigm is at our present stage further to be found than the method you've just used to describe it with. Counting new methods is possible, but it is truly meta-counting, separate even from counting meta-hierarchies of operator-character cycles. There is no method to automatically count next methods.

Born stubborn you can also try to count paradoxes that arise philosophically, because bigO is now so powerful that it created hierarchies of language constructs to describe its inner processes.
You've just counted 1 for the paradigm paradox, I feel more will follow.
Paradox counting is also meta-counting, perhaps on the same meta-level as paradigm counting, perhaps on a higher meta-level.
We cannot use paradigms and paradoxes to create countable numbers directly, though they can be used afterwards to classify our quest for counting methods.

Are there even higher meta-levels to classify our counting methods? I doubt it: the paradox must be highest. The fact that 1=0 is the highest limit of infinite Set theory (and that theories must revise their axioms at the 1=0 point) refers to that.
Strange that we found at least 1 paradox while counting integer numbers. This is more than we could hope for at the start!
Strange start too with that Set {0,1}, perhaps there is nothing after all...

Cascading Universes

All the quantum-information in our universe is isomorphic to a binary number no bigger than O(5,2,4) = 5^^5.
But the laws of nature limit the set of allowed positions for quantum-particles much further, reducing the amount of quantum-possibilities, much like a picture that is compressed to a much smaller file. Quantum-information is interconnected and reducible by laws of nature. That is why scientists feel they make progress when they find new principles of nature, such as the proposed Higgs field which is now under investigation at CERN.

Is there a reason for the presence of the laws of nature? Well... our universe could literally be engaged in a process of 'zipping up' or 'being unzipped', subservient to some unknown mathematical compression system in a higher universe.
From a number-information perspective a universe needs a precise number to exist exactly as it is. The deeper we probe into the laws of nature the more exactly defined its constants. There is no reason why counting should stop. My speculation is that the physicists at CERN will discover more than they bargained for.

Anyhow, the integer space between the universal number (of all quantum-states throughout all of time and space) and the infinity mathematicians so easily talk about, can be physically filled with an incredible cascade of systems or worlds, one on top of the other.
As a 'top system' typically processes data from a 'bottom system' with a size not far below its own size (surely no extra bigO parameter is needed), the human vision of a divine intervention for our souls after death provided by a Kingdom ruled by a God, if true, also implies a cascade of Kingdom systems of Gods, one on top of the other, ruling our universe by proxy.

Multiple systems may be intertwined in our world and our souls, the small essentially equal to the big, a shadow of a thought just as important as a World Cup.
There are surely ethical and religious principles that transcend the material plane of our quantum-mechanical universe. Principles independent of our present physical state, yet fundamental to divine life at any level in the cascade, are of utmost importance for the survival of human life and consciousness.
For example: higher life forms have a responsibility towards lower life forms. The relation of man with animals and plants and ecosystems on this earth is a great metaphor for ethical conduct between beings at separate levels of the cascade of universes that we reside in with our principal God.

Infinite Infinities

Georg Cantor invented a number that is so large that it can not be part of the set of countable numbers. That number is called "Omega" ω and it is known as the size of the set of natural numbers.

Put 0ω = 1 to begin with, so the natural numbers become part of the family of uncountable numbers.
Cantor's 1ω is the ceiling that can never be reached by counting alone: an uncountable type of number.

Substituting 1ω for 1 in bigO you can start counting infinities.
Then you can hypothesize a number that cannot be reached by such counting with 1ω, a doubly uncountable: "Omega-2" or 2ω and start the procedure again by substituting 1:=2ω
3ω, 4ω, why not increase the n in nω right away?

Then ωω and ωωω are the new frontiers.
And then you can count up to an Omega number of Omegas: ..ωω [ω#1ω]

A "bigOmega" operator function Ω() can be set up, that works in the chained style of bigO (and later bigQ):

Ω(a) = a

Ω(a,1) = aω
Ω(a,2) = ..ωω  [ω# a]
Ω(a,3) = ..ωω  [ω# aω]

Ω(a,b) = ..ωω  [ω# Ω(a,b-2)]
Ω(a,b,1) = ..ωω  [ω# Ω(a,Ω(a,...Ω(a,a)...)) a##b]

Ω(a,b,c) = ..ωω  [ω# Ω(a,Ω(a,...Ω(a,a,c-1)...,c-1),c-1) a##b]

Ω(a,b,c,1) = ..ωω  [ω# Ω(Ω(a,b,c),Ω(a,b,c),Ω(a,b,c))]

Ω(a,b,c,d) = ..ωω  [ω# Ω(Ω(a,b,c,d-1),Ω(a,b,c,d-1),Ω(a,b,c,d-1),d-1)]

etc. substitute Ω for O | Q in formula for chained bigO | bigQ
Higher infinities that cannot be reached by this 0Ω function, must be discovered by further operator-cycling with nΩ as hinted at above for nQ. Etc...

The Circus

At some point (in the spirit of Omega) you can hypothesize a more infinite number (above the ceiling-cascade of Omega) that cannot be reached by any Ω-type function for counting higher infinities. Such a number might be called 'untouchably uncountable'.
Postulating the existence of untouchable numbers beyond infinity, the whole circus can start again, applying already familiar methods.

Let's call the first of those untouchables "Psi" 2ψ and put 1ψ=ω and 0ψ=1
Then we create an operator function "bigPsi" 2Ψ() etc. supstitute 2Ψ in Ω-formula
Postulate a new untouchable-ceiling and the next 3ψ and 3Ψ and model 2Ψ := 3Ψ
Postulate the next nψ and nΨ where n-1Ψ := nΨ models the next bigPsi-function.

Infinite book of records number: 20080501ΨΨΨ(2008ω:5;1ω)

After this a bigPsi-superscript hierarchy takes shape, which in turn can be made uncountable and untouchable and what not?!
Neptune may be the last planet, but the Circus never stops.

---

I rest my case, and wish you a lovely day

Fransix

1

---

---

24455