sitemap →

# van NovaLoka

a blog of hope

## 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 `cn>0` follows just one rule :
`:c1,..,cj,ck,..,cn;` type separators (where `ck` is the first `ci>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 `2`, not much...
Suppose we count `X` levels, and on each level `n` there's a row of parameters of size `X` filled with numbers `X` separated by `;` of level `n+1`
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 `n` 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-1`spaces 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?

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 Paradigm777".
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...

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

posted on Friday, May 02, 2008 11:54 AM

### Feedback

#### #re: Neuropol 0 5/2/2008 4:07 PMRichard Gill

Beautiful! But who is the guy in the background? Rasputin or Cantor?

The best lecture I ever heard in mathematics was delivered by John Horton Conway to a small group of interested students forming the Claire/Girton/Caius maths club (if my memory serves me well). Though mathematicians we thought also of girls, hence Girton's presence.

He told us about the infinite ordinals using a tiny square blackboard on a shaky easel, which was all we had available in whichever junior combination room this lecture was given. At some point he got to omega. Then a long time later omega squared. Then later still omega cubed... and so on. After an incredibly long time omega to the omega. More and more went on, at some point one got to omega to the omega to the omega. And so on... at last he had omega to the omega to the omega to the omega ... which he decided to call epsilon sub zero.
He turned the blackboard over and wrote epsilon sub zero. And explained how as you went on and on eventually you reached epsilon subscript 1. And so on. After an INCREDIBLY long time you got to epsilon sub omega. Then after an even incredibly longer time epsilon sub epsilon.

You can guess how things went on. Some time later he had epsilon subscript epsilon subscript epsilon subscript epsilon ....

Then he said: well I needn't have written all this down. He turned the blackboard over so we could see again omega superscript omega superscript omega ...

Then he turned it 90 degrees clockwise and all the omegas turned into epsilons, and the superscripts turned into subscripts.

I always really wanted to work in the foundations of mathematics, but I never believed I would ever be able to earn a livelihood like this, so I became a statistician instead.

#### #re: Neuropol 0 5/2/2008 4:15 PMNeuropol van NovaLoka

Well, here we are a lot quicker...

#### #re: Neuropol 0 5/2/2008 4:58 PMNeuropol van NovaLoka

Hi Richard,

today in the exposition I skipped the usual fuzz you mention in your feedback, Richard.
That is Omega arithmetic which comes in between my sentence:

"Substituting Omega for 1 in bigO you can start counting infinities"

And my next sentence:

"Then you can hypothesize a number that cannot be reached by such counting with Omega"

So what professor Conway wrote on the blackboard is handled here by bigO with Omega in the parameters.

But the subscripts you mention denote smaller infinities.
My Omega subscripts denote newly postulated infinities that cannot be reached by Omega arithmetic with bigQ.

The subscripted numbers John Horton Conway described can be captured by the first 4 parameters of bigO. The largest numbers in his exposition (that you seem to have remembered remarkably well!) are:

omega ^ omega = bigO(omega,2,2)

epsilon-0 = bigO(omega,omega,2)
epsilon-1 < bigO(omega,omega,4)
epsilon-2 < bigO(omega,omega,5)
epsilon-omega < bigO(omega,omega,2*omega) ~ bigO(omega,0,0,1)

Yes, I think the fourth parameter of bigO will suffice for the rest of those numbers too, though they don't match up the same, so it seems.

I can't see this proces reaching anywhere near a dimension-2 array for bigO with omega instead of 1.

My infinities are far bigger!
thank you so much for such comforting post Richard...

#### #re: Neuropol 0 5/2/2008 5:00 PMNeuropol van NovaLoka

The guy on the photo is someone unknown from 150 years ago.
Perhaps his name was John Scott.
So the story goes.

#### #re: Neuropol 0 5/3/2008 1:13 AM8. Krupp

It is Hasnik:

* A + B = A (A-1 + B-1) B = B (A-1 + B-1) A = A (A-1 + A-1BA-1) A = B (B-1 + B-1AB-1) B
o A + I = A (A-1 + I) = (A-1 + I) A
o A-1 + B-1 = A-1 (A + B) B-1 = B-1 (A+ B) A-1 = A-1 (A + AB-1A) A-1 = B-1 (B+ BA-1B) B-1
o A-1 + I = A-1 (A + I) = (A + I) A-1
* AB + BC = A (A-1B + BC-1) C
* (A-1 + B-1)-1 = A (A + B)-1B = B (A + B)-1A = A - A (A + B)-1A = B - B (A + B)-1B
o (A-1 + I)-1 = A (A + I)-1 = (A + I)-1A = A - A (A + I)-1A = I - (A + I)-1

#### #re: Neuropol 0 5/3/2008 2:13 PMPiepie

Pur?am ada? pur?am idam
Pur?at pur?am udacyate
Pur?am evavasi?yate.

#### #re: Neuropol 0 5/3/2008 8:34 PMNeuropol

Toepasselijk citaat! Who is Piepie?

And to Hasnik, I'll look into this later!

Mooi Fran6

#### #re: Neuropol 0 5/5/2008 3:41 PMtess

De lemniscaat als teken van eeuwigdraaiende melkzuren ;-)

p@3

#### #re: Neuropol 0 5/5/2008 3:44 PMtess

Ik ben blij dat je weer aan het bloggen bent geslagen.

Keep the good word up!

x Tess

mC! is ietsje anders dan mC2 maar toch!

:o) Tess
Tf8

#### #re: Neuropol 0 5/5/2008 7:31 PMFranzes

I guess Piepie is Piet...

Het vers is heel mooi, ik ken een bhayan nog opgenomen door George Harrison voor de Hare Krishna's met deze tekst: Prachtig!

Nog even het Sanskriet vers (invocatie van de Isopanisad of Isha Upanisad):

"Om purnam adah purnam idam
purnat purnam udacyate
purnam evavasisyate"

Letterlijke vertaling:

"Om ! That is full; this is full, (for) from the full the full (indeed) arises.
When the full is taken from the full, what remains is full indeed.
Om! Peace! Peace! Peace!"

Hare Krishna betekenis:

"The Personality of Godhead is perfect and complete, and because He is completely perfect, all emanations from Him, such as this phenomenal world, are perfectly equipped as complete wholes. Whatever is produced of the Complete Whole is also complete in itself. Because He is the Complete Whole, even though so many complete units emanate from Him, He remains the complete balance."
http://www.harekrishna.com/col/books/rp/ISO/iso-inv.html

pE!

#### #re: Neuropol 0 5/6/2008 9:28 AMPiepie

Piepie = nie pie

That is full, this is full
From the full, the full is subtracted
When the full is taken from the full
The full still will remain

#### #re: Neuropol 0 5/6/2008 1:53 PMFransix

Dear nie pie (rising early in the Netherlands),

Omega is the first infinite number from which a non-infinite number can be subtracted without reducing it.

But to subtract "a Piepie-purnam number" P from P and still have a full P,
means: P-P=P or P+(-P+P)=P+P or P+0=P*2 or P=P*2
and believe me or not: Cantor provides for such P=P*n, the first such P I think must be P=omega*omega

I read in Conway and Guy's book of numbers that: omega^epsilon=epsilon
Why limit the grace of God?

http://www.amazon.com/Francesco-Mickey-Rourke/dp/6304810792

#### #re: Neuropol 0 5/6/2008 1:59 PMFransix

the blackboard, made me realize that the subscripts I use are different from the usual ones. As said, the usual superscripts and subscripts are neatly expressed in a very modest bigO parameter list.

But to avoid confusion with conventional subscripts, I've decided to use BACKWARD SUPERSCRIPTS for the final version of my bigO circus story.

------------------------------------------------------------

To my regrets I made some mistakes in translating the cardinal arithmetic Omega constructs to bigO.
I'll starts again from the beginning:

"At some point he got to omega.
Then a long time later omega squared.
Then later still omega cubed... and so on.
After an incredibly long time omega to the omega."

omega = w = bigO(w) = O(w)
omega^2 = O(w,2,2)
omega^3 = O(w,3,2)
omega^omega = O(w,w,2) = O(w,2,3) = w^^2

"More and more went on, at some point one got to omega to the omega to the omega.
And so on...
at last he had omega to the omega to the omega to the omega ... which he decided to call epsilon sub zero."

I do powers like this: (a^b)^c

(omega^omega)^omega = w^(w*w) = O(w,O(w,2,2),2)
((w^w)^w)^w = O(O(w,3,2),2)
(((w^w)^w)^w)^w) = O(O(w,4,2),2)
epsilon = epsub0 = ((w^w)^w)^... #w = O(O(w,w,2),2) ~ O(w,2,3) = w^^2

"He turned the blackboard over and wrote epsilon sub zero. And explained how as you went on and on eventually you reached epsilon subscript 1. And so on."

I guess:
epsub1 = (epsub0^epsub0)^... #epsub0 = O(O(w,2,3),2,3) < O(w,3,4)
epsub2 = (epsub1^epsub1)^... #epsub1 = O(O(O(w,2,3),2,3),2,3) < O(w,4,5)
epsub3 = (epsub2^epsub2)^... #epsub2 < O(w,5,6)

"After an INCREDIBLY long time you got to epsilon sub omega.
Then after an even incredibly longer time epsilon sub epsilon."

epsubOmega = O(...O(w,2,4),...2,4) = O(w,w,w) = O(w,0,0,1)

Here epsubOmega is the same if I had done: a^(b^c)

epsub(omega*2) = O(epsubOmega,epsubOmega,epsubOmega) = O(w,0,0,2)
epsub(omega*omega) = O(w,0,0,w) = O(w,w,w,w) = O(w,0,0,0,1)
epsub(omega^omega) = O(w,0,0,w) = O(w,0,0,0,0,1)

I suppose that:
epsub((omega^omega)^omega) = O(w,0,0,0,0,2)
epsub(omega^(omega^omega)) = O(w,0,0,0,0,0,1)
epsubEpsilon = O(w,0,0,0,0,0,1) ór O(w,0,0,0,0,0,0,1)

"You can guess how things went on.
Some time later he had epsilon subscript epsilon subscript epsilon subscript epsilon .... "

epsubEpsubOmega ~ Osub8(w,0,0,0,0,0,0,1) ór Osub9(w,0,0,0,0,0,0,0,1)
epsubEpsubEpsilon ~ Osub11(w,0,0,0,0,0,0,0,0,0,1) ór Osub13(w,0,0,0,0,0,0,0,0,0,0,0,1)
epsubEpsubEpsubEpsilon ~ Osub15(w,0,...,1) ór Osub18((w,0,...,1)
epsubEpsub...Epsilon [eps#n] ~ Osub(5*n-2)(w,0,...,1)
alpha = epsubEpsub...Epsilon [eps#omega] ~ O(w;1)

"Then he said: well I needn't have written all this down. He turned the blackboard over so we could see again omega superscript omega superscript omega...
Then he turned it 90 degrees clockwise and all the omegas turned into epsilons, and the superscripts turned into subscripts."

A wonderful spectacle indeed! So one 90 degrees turn means to go:
from epsub0 to epsub...Epsub0 [epsub#omega] =
from O(w,2,3) ór O(w,2,4) to O(w;1)
Which means going from a point to a line dimension.

Then as far as I can see:
Another 90 degrees will take us to a second line in bigO or to the 3d dimension.
In the latter case turning the blackboard means adding a dimension to the bigO parameter list.

Some further conjectures:
Turning the blackboard an omega times creates a square parameter array with rows of length omega.
Turning the blackboard epsilon times creates a cubic bigO parameter array with squares of size epsilon.
Turning the blackboard alpha times creates a bigO parameter array with alpha dimensions of size alpha.
Let's call this number bèta.

Then turning the blackboard bèta times will be like going to the next extra dimension.
These numbers do become bigger than I thought, I apologize Richard,
with bèta we've entered the realm of double separator character superscripts.

An infinite number with an omega number of separator character superscripts is the current top of my understanding of substituting omega for 1 in bigO.
I'm working to smooth that part of the bigO theory out for normal numbers, then omega can follow.

Thanks again! You're a great teacher!
z!6

#### #re: Neuropol 0 5/6/2008 3:34 PMFransix

Hasnik / 8. Krupp gives me a difficult time for I wasn't able to Google any information about this.
I recognize these rules to be profound, so I must solve this myself.
My questions would be: is this expressible in bigO? and then: how fast does this grow?

precedence rules: X-1, X Y, X + Y
axiom: 1-1 = 0

* A + B = A (A-1 + B-1) B
= B (A-1 + B-1) A
= A (A-1 + (A-1) B (A-1)) A
= B (B-1 + (B-1) A (B-1)) B

o A + I = A (A-1 + I)
= (A-1 + I) A

o A-1 + B-1 = A-1 (A + B) B-1
= B-1 (A + B) A-1
= A-1 (A + A(B-1)A) A-1
= B-1 (B + B(A-1)B) B-1

o A-1 + I = A-1 (A + I)
= (A + I) A-1

* AB + BC = A ((A-1)B + B(C-1)) C

* (A-1 + B-1)-1 = A ((A + B)-1) B
= B ((A + B)-1) A
= A - A (A + B)-1 A
= B - B (A + B)-1 B

o (A-1 + I)-1 = A (A + I)-1
= (A + I)-1 A
= A - A (A + I)-1 A
= I - (A + I)-1

I think this is the whole system...
I'll look into this later.

#### #re: Neuropol 0 5/6/2008 4:31 PMFransix

Some serious big numbers:

http://www.mrob.com/pub/math/largenum.html
http://www.mrob.com/pub/math/largenum-4.html#bowers_ext
http://www.mrob.com/pub/math/largenum-7.html#personal
http://www.polytope.net/hedrondude/array.htm
http://www.polytope.net/hedrondude/scrapers.htm

Beyond multi-dimensional array blocks for a chained-arrow style bigO function we've entered the realm of double "dimension separator" superscripts.

I'm working on that, a function to address multiple coefficient "dimension separators" directly is the best strategy forward I believe....

#### #re: Neuropol 0 5/6/2008 8:33 PMMMM

Why is Mathematics so complicated when things are so simple in reality???

Or is it just for people with brains to play games?

God = EVERYTHING

;o)

#### #re: Neuropol 0 5/7/2008 12:22 AMPiepie

Piepie smiles. =)

#### #re: Neuropol 0 5/7/2008 11:00 PMFransix van NovaLoka

The answer is Mairead, that things in reality are not really that simple. Reality is all about Einstein and I can't even start to comprehend him...

So I am doing simple math to pass the time and feel useful, a little bit.

:o)
Are you still so strong Mairead?
So good to hear from you again!

Fran6

#### #re: Neuropol 0 5/29/2008 6:02 PMMMM

Hi Fransix,
I love your blog... esp. recently!!!
Yep... I'm still strong... stronger than ever!
New York City Monday coming...

#### #re: Neuropol 0 12/29/2008 5:32 PMvan NovaLoka

A comprehensive guide to the theory and practice of monadic programming in Haskell