sitemap →

# van NovaLoka

a blog of hope

## 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 `M3`)

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 `*1` can be specified as:
`a*1b = a**...a [*#b] = O(a,a,b)`
`a*1*1b = a*1a*1..*1a [a#b]`
`a*1*1*1b = a*1*1a*1*1...*1*1a [a#b]`
etc.
A second higher operator `*2` as:
`a*2b = a*1*1...a [*1#b]`
`a*2*2b = a*2a*2..*2a [a#b]`
etc.
And further higher operators `*d` as:
`a*d1b = a*d*d...a [*d#b]`
`a*d*db = a*da*d..*da [a#b]`
etc.
Defining an operator function `O(a,b,c,d)`,
where `d` is the type of a higher operator `*d` in an expression `a*d*d...b`,
and `O(a,b,c,0) = O(a,b,c)`, and `O(a,b,0,d) = a`

Further types of operators `*d,e` can be specified similarly:
`a*d,1b = a*d*d...a [*d#b] = O(a,a,b,d)`
`a*d,e1b = a*d,e*d,e...a [*d,e#b]`
`a*d,e*d,eb = a*d,ea*d,e..*d,ea [a#b]`
etc.
Defining an operator function `O(a,b,c,d,e)`,
where `d,e` is a type of higher operator `*d,e` in an expression `a*d,e*d,e...b`

We can specify an arbitrary number of coefficients for an operator `*d,e,f,...` similarly
and use it to extend the definition to the first row of parameters of an operator function bigO:
`O(a1,...,an)`

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 `L3 = 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 `O2(a,b,c)`,
where `c` is the number of commas in an operator function `O(a,,,...b) [,#c]`
and `O2(a,b,0) = O(ab) = ab`

A higher separator `,2` can be specified as:
`a,2b = a,1,1...a [,1#b] = O2(a,a,b)`
`a,2,2b = a,2a,2..,2a [a#b]`
`a,2,2,2b = a,2,2a,2,2...,2,2a [a#b]`
etc.
And further higher separators `,d` as:
`a,d1b = a,d,d...a [,d#b]`
`a,d,db = a,da,d..,da [a#b]`
etc.
Defining `O2(a,b,c,d)`

We can specify an arbitrary number of coefficients for a separator `,d,e,f,...` similarly,
and use it to extend the definition of the operator-separator function bigO2 as `O2(a1,...,an)`

Append double, triple, multiple commas in bigO2 as above to create a multi-dimensional parameter list.
Then define a higher operator function `O3(a,b,c) = O2(a,,,...b) [,#c]`
and develop `O3()` and its successors `On()` similarly as `O2()` and `O()` before.

Create a next type of operator function bigO1,1 where:
`O1,1(a,b,0) = O0(a,,...a) [,#b] = a**...a [*#b] = O(a,a,b)`
`O1,1(a,b,1) = O(a,,...a) [,#b] = O2(a,a,b)`
`O1,1(a,b,2) = O2(a,,...a) [,#b] = O3(a,a,b)`
`O1,1(a,b,c) = Oc(a,,...a) [,#b] = Oc1(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...

posted on Monday, August 25, 2008 10:10 AM