Multidimensional Numbers Theory (MDNT)

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.
IntroductionThe MDNT theory is an extension of the "Complex Number Theory (CXNT)". MDNs exist in an Euclidean space. Starting from a 3dimensional space, basic math is generally asymmetric / distorted. Specifically, when using the higher dimensions, no rotation algorithm preserves the graphical symmetry exhibited by the rotation in a 2dimensional 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. The chosen polar form allows rotation to be independent of the number of dimensions. For example, in a 3D space, multiplying a point with itself can cause a rotation in the third dimension only if the point has a nonzero coordinate in the third dimension; if the third dimension coordinate is zero then its angle is also zero, so adding zero to itself is still zero. The chosen polar form allows rotation to be commutative, that is, it guarantees that the order in which the angles are rotated is irrelevant in generating a given cartesian form (= reaching the same point in space). Specifically, one angle is in the plane formed by the first two axes (XY), while the rest of the angles are along the rest of the axes (like XYZ). The alternative of having angles / rotation in each plane formed by every pair of axes generates different cartesian forms, depending on the order of angle rotation. In the MDNT there are many relational polar solutions for an equation, solutions which don't exist in the CXNT. For example, in a 2dimensional 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 Ddimensional 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).
DefinitionsMultidimensional numbers = Multinumbers = MDN. Ddimensional space = A space with "D" dimensions. Dimensions of z = Dim(z) is the number of axes used to make calculations. Dim(z) >= 2. All axes 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} (Ddimensional 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 formA 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] + .... + Dd.cart[d].
Polar formThe polar form is the set of polar factors (module and angles) that are associated to a cartesian form. A 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).
ModuleThere is only one set of partial reduced modules that define a 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.
AnglesThere 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 anglesRelational angles depend on each other to define a MDN. There are 2 ^ (d  2) sets of relational angles for a 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 anglesThere are an infinite number of sets of solution angles for a MDN: ang_sol[i] = ang_rel[i] + 2 * pi * k[i], where k[i] Î Z.
Generating the relational formTo generate the relational form of a 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 factorsz.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 formcart[i, i = 1...d ] = mod_red * trig[i].
Mathematical functionsA 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. A MDN is an unsplittable block of coordinates. 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 2dimensional space with multiplication over addition).
Degreedgr(x) is the number of axes 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
Orderord(x) is the number of axes 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
Imagex.cart[i] = x.cart[i] / x.mod = x.trig[i]
Mirrorx.cart[i] = x.cart[i]
Inverseinv(x) = 1 / x = 1 / x.mod * (x.trig[1]  x.trig[2]  ....  x.trig[d])
Equalityx, y Î MDN{d} are equal if each cartesian factor is equal: x.a[i] = y.a[i]
AdditionThis operation represents the translation of a point. (x + y).cart[i, i = 1...d] = x.cart[i] + y.cart[i]
SubtractionThis operation represents the translation of a point. (x  y).cart[i, i = 1...d] = x.cart[i] – y.cart[i]
MultiplicationThis 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]
DivisionThis 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 exponentiationHere, 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.
Natural logarithmln(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 logarithmCorrect for 2 dimensions. log{y}(x) = ln(x) / ln(y) log{y}(x) = D1 / log{x}(y)
PowerCorrect for 2 dimensions. x ^ y = E ^ (y * ln(x))
Sin / CosCorrect 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 multiplicationThere 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 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. It should be noted that multiplication should be defined as the rotation of a point, so a random algorithm labeled "multiplication" is not enough. 