Here are some examples of chaotic imagery. n0n theory and its relation of Gravity.  A new number theory yet to be found. Rhythm of wholeness to primes.

The following is an event that can and should be calculated because, as far as I know, no one else has calculated it. Since I am the first to do so, I might connect some things that don't really have any connection. That is the definition of reduction to absurdity. It's bad. If you see connections that don't make sense, then please point them out. Doing so will help me understand more about this exploration into mathematics, and possibly prove it totally wrong, in which case I can thank you and would move on with my life. But since this is simply a really in-depth view on division, I don't know if I could even be convinced of it.

First off: some rules about 0 (zero), because space and 0, which should be the same thing, are actually separate. You cannot explain mathematical 0 with space and you cannot explain space with mathematical 0. This always has people questioning, "What is space without existence in it?" If you take all energies from space, without all the turbulence of energy clashing into every other energy, space is uniform everywhere. We can then draw some defining points involving 0 and space, and maybe understand what might have started the big bang (it's pretty far-fetched, but who knows).

Space and 0 must be the same. If you apply the fourth dimension to space, you get the fabric of space time; but if you apply the fourth dimension to 0, then you get 0 in a series of frames. This doesn't explain empty 4D space at all. First, lets look at how there is only one 0, to which there is no mathematical way to prove there is only one 0. It is a question of philosophical needs, I think. Maybe there is a way to prove it, I don't know.

There can be 1 of anything, and even 2 of anything, etc.; but to have 0 of something means the same thing every time: some virtual random image applied to 0, because you cannot associate an object of truth with truth.

1 apple (true), 0 apples (false): 1 apple (true), 0 (true)

Ask yourself: "What's not around me?" The answer is always random. I thought, "Jaguars coming to eat me." But that's false, because the right answer to the question is 0. Don't get me wrong, we understand that 0 apples means there were apples at one point, associating the meaning to what was once there. But true 0 lacks the ability to be associated with objects at all.

1 (apple) + -1 (took an apple) = 0

Therefore:
  1. Space and 0 is a reflection upon itself.
    Remember this applies for both because there is only one 0 and therefor one space.
  2. Moving in one direction means not moving at all in an infinite series of reflections.
    This means it is expandable in directions we cannot imagine correctly, but can be calculated correctly.
  3. 0 reflecting upon itself causes a feedback of uniformity.
    I also consider it an empty loop, in consideration of the second rule.
  4. 0 should yield no information, and if it does it's random data.
With these rules in place we can apply the fourth dimension to 0 and get space time. So a new reflective 0-space hybrid is born (space works just fine). 0 is also the oil that makes mathematics work frictionless. If we are given one number, say 105, what can you determine? You cannot determine anything about a single number just being there. Likewise with a random number, as there is nothing to describe it. It will float around forever or just vanish... either way, it is essentially void.

If two random numbers come into play, then something that can happen. A reaction occurs if they touch or have 0 distance between them. I'm not sure if this would work, but 1/2 truth + 1/2 truth = 1 whole truth only if it leads to an infinity of some form. Let's say that two random numbers appear: 150 and 98. The image linked below shows that, with reflective space, two random states touching makes a lot of data. I don't know what numbers made our universe. I don't know if the numbers were as small as three digits, if the numbers were trillions of digits long, or if the latter could be an understatement by any feasible amount.

I do know that plotting the numbers geometrically tend to look like waves or particles, and can explain stationary (or like-moving particles) and fast moving particles (gravity is a bit early to bring up, so I won't just yet). Here are a couple of the different positive and negative reduction combinations. They can occur all at once or individually. Infinity separates the different types.

  

Saying "nearly infinite expanding logic" tells you that I am more a musician than a mathematician, but even so I cannot tell the difference in writing music and this idea of 0. It isn't totally infinite. It's just rational. A rational universe. We might have pointed right at the thing and completely missed it.

When you divide 150 over 98 you get 1.530612244897, continuing on until the series repeats. But at each digit another reduction can again take place. Where 1 is 150/98 to 98/52 to 52/46 and so on in the picture above, the 5 is 98/30 to 30/68 to 68/38 to 38/30 to 30/8 to 8/22 to 22/12 to 12/10 to 10/2 to 2/8 to 8/6 to 6/2 to 2/4 to 4/2 to 0. The latter doesn't explain it perfectly, but you get the idea why there is so much information.

This reduction can be displayed as , explained next. A/B = C, where C is and the process of continued calculation of C is defined by , reading more like computer code than an equation. A = 150, B = 98 and the | separates the action of a second part to the single calculation, the second part being A*10. If you loop you will see that you get the continued rational of 2 numbers, C of A/B = C. is necessary to understand before .

Now how is division explained by 0? Well, it's the reflective property of 0 that gives division its ability to go ever-smaller. The A*10 allows this, I like it, because the *1 is like copy A to + holder. If we thought of this reduction as part of humans looking at mathematics, a reflection, then it would really be an expansion. Changing over to this new reflective state, mathematics is a plane lubricated by 0 distance between comparisons and their reflected reciprocal attributes.

The Fibonacci sequence can be shown as A+B | B = previous A or A+B|B A. Thus, reduction can now be understood as . The images above can be shown as simply but the amount of information it yields in mind blowing. Pretty simple, right? Oh, the 'int' of simply means return the whole digit, so 2.56 will returns as 2.
Figure 1.2a

The top two numbers are all that's needed to create the image above (Figure 1.2a). The two on the upper-left corner of Figure 1.2a show how many reductions are taking place: one for 3248/6806 or A/B = C, the other for every C in A/B = C|B A once, and that becomes its own A/B = C|B A until 0. You get the picture, I hope. Later, I will explain how division, reflection, and dimensionality fit together hand in hand. Cool picture, don't you think?

Figure 1.2b

The image above (Figure 1.2b) shows the single reduction of 3248/6806 (the plotting of simple division) and the image above that one (Figure 1.2a) is the same, but with 2 reductions. You can see the total population and placement count are 1404. I know in the image of Figure 1.2b it says 1405 and 1404, but they are both the same. In a way, it's good that it happened this way because I can explain the differences more easily. I will correct this. It's only off by one, even on the second reduction, so it's not that big of a deal. The 1404 is the total number of placements down a divisional series, in the case of both images above it is 3248/6806.

In the larger image you can see that there are 1404 divisional placements, as well. This means that every step or loop of the calculation can also be processed to 1404 different places. In the larger image the total number of calculations is 1,975,430, so it took a few seconds to render. The 164 in both images are one of two numbers that account for distance. You may have noticed some image wrapping on the larger image above. I hope I can explain this in a mathematically meaningful way, but that will have to wait until later.

Now I'm going to give an explanation of dimensionality. 0 dimension (0D) is a single point of infinite smallness. Add feedback and a line occurs, as a series of 0D '0000000000'. Adding another dimensional feedback to the 1 dimension (1D) and it becomes 2D. Add feedback to a 2D image and it becomes 3D. Feedback to a 3D image leads us to some questions. What does the hypercube, expansion, and time have in common? The fourth dimension. With good reason, things get piled up at the fourth dimension. The image below helps show why. It is the series of graphically displayed A/B = C I mentioned earlier.

Figure 1.4

Time in this picture is a single direction, and direction does not lay in space dimension, only in pushing expanse. I say time is directly expansion as it causes the big bang events, even up until now. Science considers time an increment of frames, like a movie, but that explanation doesn't explain time over the vast reaches of light that has been moving since the big bang. It only covers observable space in the present. If expansion is time on all levels of things, and is always expanding equally with every point, then speed becomes a matter of complexity, and we wouldn't notice so much the separation between the hypercube and time. The hypercube represents time as the BA. The separation can be seen as time is always stepping forward and the hypercube is saying it can be remembered.

An increment on a 3D series could be an increment upon time and, depending on the series' complexity, it would determine its relative position per increment relative to all other points, like in Figure 1.2a. Then one state can be compared to another in its own time and expansion for every existing increment in points. The logical state I'm talking about is C, as mentioned earlier, of A/B = C. Now I'll show how division is comparable to dimension. The fraction A/B is comparable to 0 dimension. C is comparable to 1 dimension as it is a series of digits. Then we add another dimension to the mix, so C must be represented as individual digits.

So the loop comes into play.

If we didn't break C down to individual digits, the only thing you would see is a 1D line drop down an x number of placements, like this. The 2D interpretation isn't all that great mathematically, but the more you look at the different types of patterns the more you can see how, even in a 2D plane, existence can exist (small .exe file).

In Figure 1.2b, all x,y,z coordinates are still used. However, they end up pasted to the radian plane as a 2D reflection, which is not the same as the 2D renderings in the program.

This is the code I used to plot to 3D. The variables fz, fx, and fy are used for degrees of rotation.
For every C of {
rot = rot + 1 (90 degree angle, per frame in time)
IF rot = 1 THEN x = x - C
IF rot = 2 THEN y = y - C
IF rot = 3 THEN z = z - C
IF rot = 4 THEN x = x + C
IF rot = 5 THEN y = y + C
IF rot = 6 THEN z = z + C: rot = 0

x1 = (x * Cos(fz)) - (y * Sin(fz))
y1 = (x * Sin(fz)) + (y * Cos(fz))
tx1 = (tx * Cos(fz)) - (ty * Sin(fz))
ty1 = (tx * Sin(fz)) + (ty * Cos(fz))

z1 = (z * Cos(fx)) - (y * Sin(fx))
y1 = (z * Sin(fx)) + (y * Cos(fx))
tz1 = (tz * Cos(fx)) - (ty * Sin(fx))
ty1 = (tz * Sin(fx)) + (ty * Cos(fx))

x1 = (x * Cos(fy)) - (z * Sin(fy))
z1 = (x * Sin(fy)) + (z * Cos(fy))
tx1 = (tx * Cos(fy)) - (tz * Sin(fy))
tz1 = (tx * Sin(fy)) + (tz * Cos(fy))
sx = 320 (screen height / 2)
sy = 175 (screen width / 2)
sz = 175 (screen distance to object)
dst = 100 (camera distance, different from screen distance)
x2 = sx + dst * x1 / (z1 + dst)
y2 = sy + dst * y1 / (z1 + dst)
z2 = sz + dst * z1 / (x1 + dst)
tx2 = sx + dst * x1 / (tz1 + dst)
ty2 = sy + dst * ty1 / (tz1 +dst)
tz2 = sz + dst * tz1 / (tx1 + dst)
Line (x2, y2)-(tx2, ty2) (3D view)
Line (x2, z2)-(tx2, tz2) (2D reflection of 3D view)
tx = x
ty = y
tz = z
}
Explained with , where one series is expanding upon another series. 

This is a bit hard to explain with just words, so I'll use some images, as well. The last few frames show how truly large it can get, but even then it's only the tip of the iceberg. There is so much information bottled up inside these sequences that it's just a chaotic mess, but what's cool is that it begins to look less like random states the more times they are repeated. There's something special when thinking the universe is a series of 1D lines, and has a multitude of areas in mathematics that open up, and can easily be related to, for instance:


For example, the motion of a bob on a spring can be calculated with a series of 1D lines. (I'm not sure if this is right, either. I'll set up another program to show what it's doing, then maybe someone can tell me.) And for all the superstring theorists out there, I think it's the motion of a bob on a spring describing the strong force that leads to superstring theory. In this process, it at least gives movement to absolute rigidity. The program is one reduction. On the second reduction, we get multi-dimensional planes because it builds off of each point in the first reduction, then off the third reduction, and so on. This behavior is shown in the image below.


So very small, it puts us in perspective of just how huge we are. Strings are mathematics down to the smallest calculable point, and by using the speed of light we can measure just how small things can get. If an atom was the size of the solar system, a string would be the size of an atom. That really dwarfs my hopes at getting enough strings to fill our solar system with matter. At least we get to see a little bit of whatever this is.

My next goal in this endeavor is to get interactions among its own 3D state and other 3D states, so that if it comes into contact with itself or another division it will cause another division and reduction, based upon the latter. Hopefully it relates to quantum with the interactions between two states.

I have also been informed that the program leads to 'division by 0' errors, which it does, but that's a limit of computers not of this understanding of division and reduction.  The code includes checkpoints so that 'division by 0' never occurs. IF a = 0 or b = 0 then jump back the previous division, move one placement, and try to reduce again unless the previous IF statement still holds true, until the placement count = population then jump back to the division before that and repeat, etc.  This continues until all divisions reach the same count of population at which point a mass reset occurs, population is increased by one, and the process starts from the beginning with the initial 2 values used.  This is necessary because it remembers exactly were it has been and ,when I get division interacting with its self done, remembers the previous interactions to obtain the current placement and direction of other division reductions.  In the explanation of gravity I still get an error but thats is distance related, I might have the black hole/ supernova thing backwards in there, I'm not sure. 

Another aspect of the program has been left out, and that is when you divide 2 numbers like 1234/13 = 94.92307692307 repeat [692307], the 94 gets broken down into 9,4.  This is necessary because looking at geometric space in this way decimal points don't exist, it is a stream of individual digits.

Any feedback can be sent to: n0n@hotmail.com.
That's n-zero-n @ hotmail.com.


All images/code are © Michael Camacho.
Please give credit if you display them elsewhere.