## Operator generation as a motor for an operator function

First the natural numbers are created:

`a = 111... [1#a]`

Addition of numbers is accomplished simply by writing numbers next to each other:

`a+b = ab`

eg. `3+2 = 111+11 = 11111 = 5`

Consider an operator `*`

for repetitions:

`a*b = aa...a [a#b]`

(multiplication)

`a**b = a*a*...*a [a#b]`

(powers with one exponent)

`a***b = a**a**...**a [a#b]`

(powers with repeated exponents)

And so on, eg. `3****2 = 3***3 = 3**3**3 = 3**27 = 7625597484987`

(my *Mann* number `M`

)_{3}

Let this define an operator function `O(`

,**a,b,c**)

where `c`

is the number of `**...`

in an expression `a**...b`

,

and `O(`

**a,b,0**) = O(**a,b**) = a+b = ab

A higher operator `*`

can be specified as:_{1}

`a*`

_{1}b = a**...a [*#b] = O(**a,a,b**)

`a*`

_{1}*_{1}b = a*_{1}a*_{1}..*_{1}a [a#b]

`a*`

_{1}*_{1}*_{1}b = a*_{1}*_{1}a*_{1}*_{1}...*_{1}*_{1}a [a#b]

etc.

A second higher operator `*`

as:_{2}

`a*`

_{2}b = a*_{1}*_{1}...a [*_{1}#b]

`a*`

_{2}*_{2}b = a*_{2}a*_{2}..*_{2}a [a#b]

etc.

And further higher operators `*`

as:_{d}

`a*`

_{d1}b = a*_{d}*_{d}...a [*_{d}#b]

`a*`

_{d}*_{d}b = a*_{d}a*_{d}..*_{d}a [a#b]

etc.

Defining an operator function `O(`

,**a,b,c,d**)

where `d`

is the type of a higher operator `*`

in an expression _{d}`a*`

,_{d}*_{d}...b

and `O(`

, and **a,b,c,0**) = O(**a,b,c**)`O(`

**a,b,0,d**) = a

Further types of operators `*`

can be specified similarly:_{d,e}

`a*`

_{d,1}b = a*_{d}*_{d}...a [*_{d}#b] = O(**a,a,b,d**)

`a*`

_{d,e1}b = a*_{d,e}*_{d,e}...a [*_{d,e}#b]

`a*`

_{d,e}*_{d,e}b = a*_{d,e}a*_{d,e}..*_{d,e}a [a#b]

etc.

Defining an operator function `O(`

,**a,b,c,d,e**)

where `d,e`

is a type of higher operator `*`

in an expression _{d,e}`a*`

_{d,e}*_{d,e}...b

We can specify an arbitrary number of coefficients for an operator `*`

similarly_{d,e,f,...}

and use it to extend the definition to the first row of parameters of an operator function bigO:

`O(`

**a _{1},...,a_{n}**)

We can append a double comma `,,`

to this row and have it followed by a second row of parameters:

`O(`

**a,,b**) = O(**a,a,...,a**) [a#b]

We can append a triple comma `,,,`

to specify a second dimensional parameter list:

`O(`

**a,,,b**) = O(**a,,a,,...,,a**) [a#b]

And so on until bigO can have a parameter list with multiple dimensions `,,,...`

Eg. my *Lady cube* `L`

_{3} = O(**3,3,3,,3,3,3,,3,3,3,,,3,3,3,,3,3,3,,3,3,3,,,3,3,3,,3,3,3,,3,3,3**)

Let this define a higher operator function `O`

,_{2}(**a,b,c**)

where `c`

is the number of commas in an operator function `O(`

**a,,,...b**) [,#c]

and `O`

_{2}(**a,b,0**) = O(**ab**) = ab

A higher separator `,`

can be specified as:_{2}

`a,`

_{2}b = a,_{1},_{1}...a [,_{1}#b] = O_{2}(**a,a,b**)

`a,`

_{2},_{2}b = a,_{2}a,_{2}..,_{2}a [a#b]

`a,`

_{2},_{2},_{2}b = a,_{2},_{2}a,_{2},_{2}...,_{2},_{2}a [a#b]

etc.

And further higher separators `,`

as:_{d}

`a,`

_{d1}b = a,_{d},_{d}...a [,_{d}#b]

`a,`

_{d},_{d}b = a,_{d}a,_{d}..,_{d}a [a#b]

etc.

Defining `O`

_{2}(**a,b,c,d**)

We can specify an arbitrary number of coefficients for a separator `,`

similarly,_{d,e,f,...}

and use it to extend the definition of the operator-separator function bigO_{2} as `O`

_{2}(**a _{1},...,a_{n}**)

Append double, triple, multiple commas in bigO_{2} as above to create a multi-dimensional parameter list.

Then define a higher operator function `O`

_{3}(**a,b,c**) = O_{2}(**a,,,...b**) [,#c]

and develop `O`

and its successors _{3}()`O`

similarly as _{n}()`O`

and _{2}()`O()`

before.

Create a next type of operator function bigO_{1,1} where:

`O`

_{1,1}(**a,b,0**) = O_{0}(**a,,...a**) [,#b] = a**...a [*#b] = O(**a,a,b**)

`O`

_{1,1}(**a,b,1**) = O(**a,,...a**) [,#b] = O_{2}(**a,a,b**)

`O`

_{1,1}(**a,b,2**) = O_{2}(**a,,...a**) [,#b] = O_{3}(**a,a,b**)

`O`

_{1,1}(**a,b,c**) = O_{c}(**a,,...a**) [,#b] = O_{c1}(**a,a,b**)

I know this sounds crazy, but I'm under the impression that an `a,b = a*b`

type construction of bigO is less fundamental than an `a,b = a*2^b`

type construction. Considering the quantum-world this may come as no surprise...