Package bigOpera

Explore number space..!

See:
Description

Class Summary

BigOpera

List numbers by counting the number of ones needed to construct those numbers using the bigO(int, int, int) method and positive integers.

Package bigOpera Description

Explore number space..!
List the minimal constructions for all numbers using the operators: + * ^ ^^

The story of the bigO operator function

In my quest for ever larger numbers the operator function O(a,...) developed in the form it now has for integer operators c >= 0.
It's best to illustrate bigO with some examples:

O() = O(0,0,0) = 0
O(2) = O(2,0,0) = 2
O(1,3) = O(1,3,0) = 1+3 = 4
O(3,5,0) = 3+5 = 8
O(4,8,1) = 4*8 = 32
O(4,3,2) = 4^3 = 64
O(2,3,3) = 2^^3 = 2^(2^2) = 16
O(2,3,4) = 2^^^3 = 2^^(2^^2) = 2^^(2^2) = 2^^4 = 2^(2^(2^2)) = 2^16 = 65536
O(2,2,2,1) = O(4,4,4) = O(4,2,5) = 4^^^^2

Somewhere I decided that I didn't need the zero and that I could just as well express very big numbers as rows of ones 111... combined inside the bigO operator function.
I separated rows of parameters in bigO by commas to increase the length of the preceding parameter list directly by bigO's astronomical number magic. And after a while these commas become countable themselves (a series of commas counts dimensions in bigO's multidimensional parameter array). Above the dimensional realm lie bigger numbers which need more than commas, and every next character becomes countable too...

When quantum-information theorists tell me their estimate of the total of quantum information bits in the universe is about 10^122 the idea that the number 2^(10^122)of the universe is less than 66.6^^3 = O(66.6,3,3) makes me feel quite comfortable… (yet entropy is increasing ;o)

The story of the Obit mathematical number system

An Obit number is the binary representation of a number expressed by bigO as O(a,b,c) and is (or strives to be) the smallest such representation.
For example: 20 = 4*5 = O(4,5,2) = 01111011111011

The Obit system has two characters: the zero 0 functions as the operator prefix and as a comma inbetween numbers, where numbers are either atomic rows of ones 1... or expressed in Obits.
When a number N has a certain size it can be more concisely expressed in Obits than by a row of 111... of length N. Each operant a,b (and more exotically operator number c) may be nested.
Every bigO function in the Obit system is expected to have 3 arguments (and 3 zeros/commas) where the third argument is set to c+1, so that addition is neatly expressed by a 1 after the last 0 (or inbetween zeros/commas if it is part of a subexpression inside bigO).
It makes no sense to express certain small numbers in bigO as their Obit size is equal or smaller than a row of ones. Numbers for which this is true are:

{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 19 }

All expressions of bigO resulting in such a number can be defined separately to have a special meaning.
Eg. the mathematical character for minus "-" may be expressed by a row of digits: 01010110 which would otherwise contain a wasteful 1.
Having a minus around increases the number of operators dramatically:
- we can subtract by adding -b in O(a,-b),
- we have division by raising a^-1 in O(O(a,-1,2),b,1) or simply by c=-1 in O(a,b,-1),
- we have logarithms log(b)/log(a) by c=-2 to zoom back from extremely large numbers,
- and also you might try the task of defining rational operators inbetween, such as I propose by c=-1/3 in O(a,b,O(3,1,-1)) = b!/a!

The story of the Obit file system

Each sequence of binary bits is essentially a number in base 2. An Obit file system uses Obit numbers to mathematically compress large files.
Because it makes no sense to have files smaller than a certain size, all expressions of bigO less than that size can be defined separately by the operating system to have special meaning.

A result of Kolmogorov's complexity theory is that the majority of numbers are most economically expressed in binary notation. The compression I seek via an Obit file system must be achieved by manipulating the original file towards a compressible number. Video files have lots of free parameters because video mimicks our visual experience of life, which in turn deals with proportions between quantities. A compression based on multiplication is more in order than the additional precision binary storage offers. Pity our computers like to add. We must compromise to get this proportional world of reality inside the bitwise computer and apply a schizophrenic counting system that has its roots in both. I see a great future for the mathematical Obit file system!

With superfluous (sub)expressions we can accomodate binary sequences too if necessary.
Eg. the number 010101 may signify that the following Obit subexpression 0...0...0...0 is the length of a row of binary bits that follows. Using a binary number inside an Obit expression requires (in this example - if the length L of the number is exactly 1Mb = 2^23 bits = 01100111001111011111011010111 = L this takes 010101L0 = 36) extra bits, but not much. Of course you can have sizes of sizes 010101010101 of binary bits too if the length of your binary number cannot be expressed economically in Obits (eg. is not exactly 1Mb).

Special subsequences need an extra last zero, but an Obit file does too if you're not sure the next file starts with a digit 0