Multidimensional Numbers Theory (MDNT)


Home

Created by George Hara. Released under a Common Sense License.

You should also read about FLT.

The source code which implements this theory is included in the C# source code archive. QuickMdn is an application which allows you to quickly test various aspects of MDNT. The C# library is naturally implemented, that is, you can write for example "y = (1 + x / n) ^ n" to represent the natural exponentiation (at limit). All operations are implemented so as to require the minimum number of conversions between cartesian and polar coordinates. Fluogen is an application which transforms MDN equations to pictures.



Introduction

This theory is an extension of the "Complex Number Theory (CXNT)".

MDNs exist in an Euclidean space.

Generally, MDNs are associative and commutative, but are not distributive. Multiplication is not distributive over addition, except if the degree of the common MDN is maximum 2; x * (y + z) = x * y + y * z if dgr(x) <= 2.

In the MDNT there are many relational polar solutions for an equation, solutions which don't exist in the CXNT. For example, in a 2-dimensional space, each cartesian solution has 2 relational polar solutions; first: the "normal" solution; second: the module is negative and the angle is added a Pi. For a D-dimensional space there are 2 ^ (D - 1) relational polar solutions, where the module and all the angles have two choices (except the first angle which depends on all the other choices).

Interestingly, even if some angles are indeterminate, the number can still be determinate (see the polar form, the angles).



Definitions

Multidimensional numbers = Multinumbers = MDN.

D-dimensional space = A space with "D" dimensions.

Dimension of z = Dim(z) is the number of axis used to make calculations. Dim(z) >= 2.

All axis of a multidimensional space, are perpendicular on each other, so they can not intersect.

Consider that:

d Î N{ >= 2 }.

p, r Î R.

x, y, z Î MDN{d} (D-dimensional space).

i, j are the index of an axis, i, j Î N{1...d}.

Di.r is the axis i of the number, with the value r (which is 1 by default).

cart[i] Î R. This is the value of the cartesian factor on the i axis. Instead cart it may be used a.

ang[i] Î R. This is the value of the angle on the i axis. Instead ang it may be used u.



Cartesian form

An MDN has a unique cartesian form, meaning that there is only one set of cartesian factors (= coordinates) that define the MDN:

z = cart[1], cart[2], ...., cart[d] = D1.cart[1] + D2.cart[2] + .... + Md.cart[d].



Polar form

The polar form is the set of polar factors (module and angles) that are associated to a cartesian form.

An MDN has multiple polar forms, meaning that there are multiple sets of polar factors that define the MDN.

The reduced polar form is the only set of reduced polar factors that define a cartesian form.

The relational polar form is formed by all sets of relational polar factors (in number of 2 ^ (d - 1)) that define a cartesian form.

The solution polar form is formed by all sets of solution polar factors that define a cartesian form (this is the relational polar form plus the periods of each angle).



Module

There is only one set of partial reduced modules that define an MDN.

All reduced modules are positive.

The partial reduced module of z on the i axis: mop_red[i] = abs(sqrt(sum{j = 1...i}(sqr(cart[j])))).

The reduced module of z is mod_red = mod = mop_red[d].

The relational module of z is mod_rel = +-mod_red.



Angles

There is only one set of reduced angles that define and MDN:

If cart[1] >= 0, ang_red[1] = asin(cart[2] / mop_red[2]) or atan(cart[2] / mop_red[1]).

If cart[1] < 0, ang_red[1] = asin(cart[2] / mop_red[2]) + pi or atan(cart[2] / mop_red[1]) + pi.

ang_red[i, i = 2...d - 1] = asin(cart[i + 1] / mop_red[i + 1]) or atan(cart[i + 1] / mop_red[i]).

If mop_red[i] = 0, the angle is indeterminate (it can have any value).

Here asin() and atan() have their domain: [-pi / 2, pi / 2].

The reduced angles have their domain:

ang_red[1] Î [0, 2 * pi).

ang_red[i, i = 2...d - 1] Î [-pi / 2, pi / 2].



Relational angles

Relational angles depend on each other to define an MDN.

There are 2 ^ (d - 2) sets of relational angles for an MDN. The first angle is determined from the rest.

Each relational angle must be:

ang_rel[1] Î [0, 2 * pi).

ang_rel[i, i = 2...d - 1] Î [-pi / 2, 3 * pi / 2].



Solution angles

There are an infinite number of sets of solution angles for an MDN: ang_sol[i] = ang_rel[i] + 2 * pi * k[i], where k[i] Î Z.



Generating the relational form

To generate the relational form of an MDN you have to choose between 2 possible cases (for each factor: the module, all angles with index [2...d - 1]). The first angle is calculated from the module and all other angles because it influences only the first 2 trigonometric factors, so this is the easiest way to do it.

Set z.mod_rel

With +z.mod_red then sign = 1.

With -z.mod_red then sign = -1.

If sign = 1 then z.ang_rel[i, i = d - 1...2] =

Choose z.ang_red[i] then sign = 1.

Choose pi - z.ang_red[i] then sign = -1.

If sign = -1 then z.ang_rel[i, i = d - 2...2] =

Choose pi + z.ang_red[i] then sign = 1.

Choose -z.ang_red[i] then sign = -1.

If sign = 1 then z.ang_rel[1] = z.ang_red[1].

If sign = -1:

If z.ang_red[1] < pi then z.ang_rel[1] = z.ang_red[1] + pi.

If z.ang_red[1] >= pi then z.ang_rel[1] = z.ang_red[1] - pi.



Trigonometric factors

z.trig[1] = multiply{i = 1...d - 1}(cos(z.ang_red[i])).

z.trig[j, j = 2...d - 1] = sin(z.ang_red[j - 1]) * multiply{i = j...d - 1}(cos(z.ang_red[i])).

z.trig[d] = sin(z.ang_red[d - 1]).



Generating the cartesian form from the polar form

cart[i, i = 1...d ] = mod_red * trig[i].



Mathematical functions

A multidimensional space closes within itself, meaning that the results have the same number of dimensions.

Generally, MDNs are associative and commutative, but are not distributive. Multiplication is not distributive over addition, except if the degree of the common MDN is maximum 2; x * (y + z) = x * y + y * z if dgr(x) <= 2.

In more than 2 dimensions, the invers method (of a method) does not necessarily lead to the initial number. Example: Mpf y = x.Sqr(); y = y.Sqrt(): y is not necessarily equal with x. Still, if before Sqrt() you set a particular solution form (you have to find it manually) of y, x would result. In this simple case, you do get " y ~== x", but in more complex cases (where conversions between polar and cartesian forms are being made) this would not always happen.

An MDN is a block of coordinates, not a list. This means that the operations with MDNs have to be computed as blocks and are not independently applicable on the individual coordinates (as it is possible in a 2-dimensional space).



Degree

dgr(x) is the number of axis up to the null cartesian factors (the factors on the right side are 0).

If a[i, i = 1...d] = 0 then dgr(x) = 0.

If a[i, i = 1...dg, dg Î {1, d}] <> 0 and a[i, i = dg + 1...d] = 0 then dgr(x) = dg

Order

ord(x) is the number of axis down to the null cartesian factors (the factors on the left side are 0).

If a[i, i = 1...d] = 0 then ord(x) = 0.

If a[i, i = 1...or - 1, or Î {1, d}] = 0 and a[i, i = or...d] <> 0 then ord(x) = or

Image

x.cart[i] = x.cart[i] / x.mod = x.trig[i]

Mirror

x.cart[i] = -x.cart[i]

Inverse

inv(x) = 1 / x = 1 / x.mod * (x.trig[1] - x.trig[2] - .... - x.trig[d])

Equality

x, y Î MDN{d} are equal if each cartesian factor is equal: x.a[i] = y.a[i].



Addition

This operation represents the translation of a point.

(x + y).cart[i, i = 1...d] = x.cart[i] + y.cart[i]

Subtraction

This operation represents the translation of a point.

(x - y).cart[i, i = 1...d] = x.cart[i] - y.cart[i]

Multiplication

This operation represents the rotation of a point.

(x * y).mod = x.mod * y.mod.(x * y)

ang[i, i = 1...d - 1] = x.ang_rel[i] + y.ang_rel[i]

Division

This operation represents the rotation of a point.

(x / y).mod = x.mod / y.mod

(x / y).ang[i, i = 1...d - 1] = x.ang_rel[i] - y.ang_rel[i]

(PR) Power, real

(x ^ p).mod = x.mod ^ p

ang[i, i = 1...d - 1] = x.ang_rel[i] * p

Natural exponentiation

Here, E = D1.e = e.

(E ^ x).mod = e ^ x.cart[1]

(E ^ x).ang[i, i = 1...d - 1] = x.cart[i + 1]

Although no mathematical proof is present, calculations show that E ^ x = lim{ N -> Inf }(1 + x / N) ^ N just as it is for e. However, even though for d = 2 we have E ^ x = 1 + sum{i = 1...Inf}( x ^ i / i!), for d >= 3 this is no longer true. This suggests that the formula for natural exponentiation is correctly chosen.

As you may see, despite what you might expect, the module of the result is not e ^ sum{i = 1...d}x.cart[i]. It appears that the module of e ^ Di.x.cart[i, i = 2...d] is 1.

What's most interesting in this formula is the fact that the cartesian system of coordinates directly translates into the polar system of coordinates. This is even more interesting as this happens at limit.

Natural logarithm

ln(x).cart[1] = ln(x.mod)

ln(x).cart[i, i = 2...d] = x.ang_sol[i - 1]

This is the inverse formula of natural exponentiation, so its mathematical proof depends on the mathematical proof of natural exponentiation.



Generic logarithm

Correct only for 2 dimensions.

log{y}(x) = ln(x) / ln(y)

log{y}(x) = D1 / log{x}(y)

Power

Correct only for 2 dimensions.

x ^ y = E ^ (y * ln(x))

Sin / Cos

Correct only for 2 dimensions.

E ^ D2.x = D1.cos(x) + D2.sin(x) = z

E ^ D2.(-x) = D1 / E ^ D2.x = D1.cos(x) - D2.sin(x) = D1 / z

=> Sin: sin(x) = (z - inv(z)) / D2.2

=> Cos: cos(x) = (z + inv(z)) / D1.2



Distributive multiplication

There is a way to have a multiplication algorithm which is distributive over adding, and is also commutative: decomposed multiplication.

Here is an example: x * y = (D1.x1 + D2.x2 + D3.x3) * (D1.y1 + D2.y2 + D3.y3) = (D1.x1 * D1.y1 + D2.x2 * D1.y1 + D3.x3 * D1.y1) + (D1.x1 * D2.y2 + D2.x2 * D2.y2 + D3.x3 * D2.y2) + (D1.x1 * D3.y3 + D2.x2 * D3.y3 + D3.x3 * D3.y3)

As you can see, the multiplication between x and y is made by decomposing x and y in their cartesian factors instead of using the polar coordinates. The only thing that we need to clarify is what it means to multiply an axis with another (Di.xi * Dj.yj). We choose the axis multiplication as follows (here, the axes indexes are [0...d) not [1...d] as usual):

If i + j < d, Di.xi * Dj.yj -> the cartesian factor for the aixs with the index i + j is xi * yj.

Else Di.xi * Dj.yj -> the cartesian factor for the aixs with the index i + j - d is -xi * yj.

The decomposed multiplication represents the rotation of the system of reference, that is, one axis becomes another. In the case of the polar multiplication (based on the polar form), the multiplication represents the rotation of a point.

This operation has a problem as well: it depends on the number of dimensions. For example (D1.x1 + D2.x2) * (D1.y1 + D2.y2) in MDN{2} and (D1.x1 + D2.x2 + D3.0) * (D1.y1 + D2.y2 + D3.0) in MDN{3} give different results.

There are other ways to do distributivity, even without problems, but none of them preserves the graphical symmetry exhibited by the normal polar multiplication.



To study

It's necessary to study the distribution of multiplication in order to see whether x * (y + z) = x * y + y * z + f( x, y, z ) if dgr(x, y, z) > 2.