CalvinDude.com

Yes, I have created yet another method of producing the factor field. This time, I’m using PHP, so anyone who’s got their own website and has a fairly recent version of PHP attached, so that the graphics libraries are on it, can use this code to make their own:

<?
define('WIDTH', 500);
define('HEIGHT', 10000);

$img = imagecreatetruecolor(WIDTH, HEIGHT);

$bg_color = imagecolorallocate($img, 255, 255, 255);
$graphic_color = imagecolorallocate($img, 0, 0, 0);

imagefilledrectangle($img, 0, 0, WIDTH, HEIGHT, $bg_color);

for ($x = 1; $x <= WIDTH; $x++){

    for ($y = $x; $y <= HEIGHT; $y = $y + $x) {
      imagesetpixel($img, $x, $y, $graphic_color);
    }
}

header("Content-type: image/png");
imagepng($img);

imagedestroy($img);
?>

That should produce this:

Here’s something pretty nifty I just discovered while messing around with my calculator (yes, I’m a geek—you’ll get over it). Let me give you a sequence of numbers, and try to guess the next number in the sequence:

0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100

I imagine most of you (well, those who tried to figure out what the next number would be) immediately recognized that this is a list of the squares of numbers from 0 to 10. In other words:

0² = 0
1² = 1
2² = 4
3² = 9
4² = 16
5² = 25
6² = 36
7² = 49
8² = 64
9² = 81
10² = 100

Knowing this sequence, you guess the correct next number in the series as:

11² = 121

Now, if you did this, you would have gotten the correct answer. But you would have done so in the incorrect way. For while a rule was used to generate the list of numbers above, that list was not generated by tabulating the list of the squares of all numbers between 0 and 10. Instead, the rule used to generate that list was this one:

Let the first number be 0.
Let the second number be the first number + 1.
Let the third number be the second number + 3.
Let the fourth number be the third number + 5.
Let the fifth number be the fourth number + 7.
Etc.

In mathematical notation, we get this:

We start with: 0
0 + 1 = 1
1 + 3 = 4
4 + 5 = 9
9 + 7 = 16
16 + 9 = 25
25 + 11 = 36
36 + 13 = 49
49 + 15 = 64
64 + 17 = 81
81 + 19 = 100

And, based on this rule, we can calculate:

100 + 21 = 121.

Now it just so happens that this sequence will give the exact same results as listing out the squares of numbers in order. This means that the list of squares is equivalent to the list generated by the recursive function of taking the previously generated value (beginning with the seed of 0) and adding in the next consecutive odd number. While this itself probably doesn’t do a lot of good for us in terms of making mathematics easier, it shows a hidden beauty that spontaneously emerges from the patterns of numbers.

In the past, I showed how to create a Factor Field using VBScript. I’ve now learned a second way to do it. Here’s the first method, with slight changes from how I’ve presented it before (just in the variable name changes):

set objExcel = CreateObject("Excel.Application")
Set objWorkbook = objExcel.Workbooks.Add()
Set objWorksheet = objWorkbook.Worksheets(1)
objExcel.Visible = True

' Use for a practical demonstration
MaxWidth = 100
MaxDepth = 150

for x = 1 to MaxWidth
	for y = x to MaxDepth step x
		objExcel.Cells(y,x).Interior.ColorIndex = 1
	next
next

wscript.Echo "Done."

If you change the MaxDepth to something larger, like say “MaxDepth = 15000” then you can see how the program works, by filling in one column at a time. However, given the symmetry in the Factor Field graph, I discovered how to program the same graph off the diagonal instead of the columns:

set objExcel = CreateObject("Excel.Application")
Set objWorkbook = objExcel.Workbooks.Add()
Set objWorksheet = objWorkbook.Worksheets(1)
objExcel.Visible = True

' Use for a practical demonstration
MaxWidth = 100
MaxDepth = 150

for i = 1 to MaxDepth

	y = i
	x = 1

	Do While y < = MaxDepth
		objExcel.Cells(y,x).Interior.ColorIndex = 1
		x = x + 1
		y = y + i
	Loop
next

wscript.Echo "Done."

If you run that (again, changing the MaxDepth value to something larger will help you see it in action, because it takes longer for the script to run), you’ll see that it creates the Factor Field by making the diagonal lines.

In the end, both graphs are identical. So, the two methods are isomorphic, which means that they’re two ways of saying the same thing. Which means that they are equivalent to each other :-)

Update: When I told my girlfriend about this post, she asked me if either method is faster than the other. So I tested it with some Now functions to see which took longer, etc. On my system, running the original version (with the width of 100 and the depth of 150) took about one second less than running it the new way. So the first method is definitely faster. My guess is because computers are faster with nested “for” loops than they are with “while” loops, but that’s just a theory.

Update 2: I realized there was a subtle error in how I ran my time benchmark test earlier. So I redid it, and I also had it iterate through each type 10 times, so I could get a 10 run average. So, the first method (using the nested “for” loops) had a 10 run average of 2.4 seconds to create the Factor Field (again, width = 100, depth = 150). The second method (using the “while” loop) had a 10 run average of 3.0 seconds. So, roughly 0.6 seconds longer.

Obviously, this means if you want to create your own Factor Field, the nested “for” loop method is the way to do it. Of course, my post was more about the isomorphic relationship between the two methods, as opposed to the speed at which one could produce them. But I like the fact that my girlfriend can provoke me to deeper learning about stuff!

Here’s a simple little computer programming/logic riddle for fun. Can you write a computer program that swaps the values of two variables without using a third variable for temporary storage? The answer is, of course you can (and it’s also very easy to do), but if you’ve not seen how before it might take a bit to understand exactly how to do it.

First off, let’s demonstrate how to do it with the easier method of using a third variable. For these examples, I’m going to use VBScript. Anyone with a Windows computer should be able to copy the text into Notepad, save the file as VarSwap.vbs (for example), then click on it and run it on your computer. (Note: WordPress automatically changes the quotes to “smart-quotes” and you’ll want to get rid of those, converting them to the plain ol’ quotes you get when you type in Notepad automatically.)

Here’s the code:

Option Explicit
Dim A, B, C

A = 5
B = 7

wscript.echo “Original Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

C = A
A = B
B = C

wscript.echo “Swapped Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

Now, to explain what this program does.

I.:

Option Explicit

This is a VBScript command that forces all variables in the program to be defined before they can be used. This is not necessary to do, because VBScript will create variables “on the fly” for you. However, it’s pretty stupid not to include it, because in more complicated programs, typos will be a pain to track down. If you make it where you have to define them from the beginning, you’ll get a syntax error instead of a new (and utterly useless) variable created, and syntax errors at least give you the line to check.

II.:

Dim A, B, C

This is the VBScript command to define our variables. We’re telling the compiler that there will be three, and only three, variables in this program, and the variables will be named A, B, and C.

III.:

A = 5
B = 7

Here we just give two different values to A and B. The one important thing to note is that the = sign in VBScript does not function the way that it does in mathematics. Instead, what that sign tells the compiler is “Set the value of the variable on the left side of the = to whatever the expression is on the right side of the =.”

So, for the first line, we have the computer commanded: “Set the value of A to 5” and the second line tells it “Set the value of B to 7.”

IV.:

wscript.echo “Original Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

This somewhat convoluted-looking statement simply causes VBScript to write out a message box that shows the original values for A and B.

V.:

C = A
A = B
B = C

And here we get to the meat of the swap. So here’s that we’ve told the computer:

1. Set the value of C to the value currently held by A.
2. Set the value of A to the value currently held by B.
3. Set the value of B to the value currently held by C.

To demonstrate this a little clearer, we can look at it further:

1’. Set the value of C to the value currently held by A. Well, the value currently held by A at this point in the program is “5” (because of the previous statement setting it to 5. So, C = 5.

2’. Set the value of A to the value currently held by B. The value currently held by B at this point in the program is 7. So now we’ve changed A, and told the computer: A = 7.

3’. Set the value of B to the value currently held by C. The value currently held by C is the value it was set to in 1’; namely, 5. So we just told the computer, B = 5.

VI.:

wscript.echo “Swapped Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

And finally, we end the program by outputting the new values for A and B.

So that’s how to do the swap with three variables. But suppose that for some reason you were only allowed to have two variables. The only reason I can see as to why this might be the case now is simply because some random teacher might assign it to you, since computing is advanced enough to not really need to worry about this now. But let’s look at it anyway. Suppose I said that your program was required to start:

Option Explicit
Dim A, B

A = 5
B = 7

And then I said you had to swap the values of A and B. Since the Option Explicit command is there, and since only A and B are defined, then how can it be done?

Well, first, note that you cannot simply say:

B = A
A = B

If you did that at this point in the program, you would be telling the computer this:

1. Set the value of B to the current value of A.
2. Set the value of A to the current value of B.

Now what happens in line 1 is that B is set to the value of A, which makes B = 5. But what happens in line 2? A is set to the current value of B, which means A = 5. Now, A and B are both 5! There has been no swapping.

So how do you get around this problem? How can you swap the values of A and B without creating a new variable to temporarily store the information?

The answer is simple, yet it is also profound. You have two chunks of information that you have to keep at all times. You can’t lose either of them. So the solution is, in essence, to make one variable contain both chunks of information, and then have a “key” that you can use in the other variable to pry out and separate those two chunks back into their components, only swapped.

So how do you do it? Well, here’s the program:

Option Explicit
Dim A, B

A = 5
B = 7

wscript.echo “Original Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

A = A + B
B = A – B
A = A – B

wscript.echo “Swapped Values” & vbCrLf & “A = ” & A & vbCrLf & “B = ” & B

Now, let’s examine the logic section to show how this works. We have the following commands sent to the computer:

1. Set the value of A to the current value of A and the current value of B added together.
2. Set the value of B to the current value of A minus the current value of B.
3. Set the value of A to the current value of A minus the current value of B.

To show how this works, you have to realize that the current value of variables does not change until after the statement is processed, and it also shows why it’s important that you cannot think of the = sign as being identical to the way it works in math. To plug in some numbers, what we’ve told the computer is this:

1.’ Set the value of A to the current value of A (5) and the current value of B (7) added together.

This means that after the statement is processed, A = 12

2.’ Set the value of B to the current value of A (12) minus the current value of B (7).

This means that after the statement is processed, B = 5.

3.’ Set the value of A to the current value of A (12) minus the current value of B (5). Remember, the current value of B changed immediately before this statement began, so it’s the new value!

This means that after the statement is processed, A = 7.

So there you have it!

It is quite obvious that my parents know me well. For my birthday, they got me DVDs from a course on number theory. This meant I was awake far too long last night watching the first set. In the process, I learned a wicked kewl way of converting kilometers to miles using the Fibonacci series.

The Fibonacci sequence starts with 1,1 as the “seeds.” Then it follows the rule, “The next number in the Fibonacci sequence is the sum of the previous two numbers.” So the sequence begins:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55

The 2 comes from adding the previous two numbers (1 + 1). The 3 comes from adding the previous two numbers, which now are (1 + 2). The 5 follows the same rule, only now the numbers are (2 + 3). Etc.

Now it happens that the ratio between numbers in this sequence approaches the golden ratio, and at infinity it is equal to the golden ratio. The golden ratio is defined as the Greek letter phi (which doesn’t show up here, so I’ll use x instead) and can be expressed as x = 1 + 1/x. This gives us a recursive equation, one that includes itself within the definition. However, this equation can still be solved by multiplying both sides by x² = x + 1. This gives us a quadratic equation, which means we want all the terms on one side. That gives us x² – x – 1 = 0. Using the binomial theorem, we can solve this to show that x = (1 +/- sqrt(5))/2.

[In the previous equation, “sqrt(5)” stands for the square root of 5.]

Now even without a calculator, we know that the square root of 5 is just a little more than 2, since the square root of 4 is exactly two. So if we subtract the square root of 5 from 1, we will end up with a negative number as our end result. But we only want the positive version, which is x = (1 + sqrt(5))/2 so we can safely ignore the negative version.

In any case, we know that 1 + a number that is a little bigger than 2 gives us a number that is a little bigger than 3. And if we divide that number by 2, we will end up with a number a little bigger than 1.5. And the golden ratio begins 1.608…

Now it just happens that 1.6 is pretty close to the ratio between a kilometer and a mile. In other words, we have about 1.6 km per mile. So if the ratio between the numbers in the Fibonacci series in about 1.6, then we can use the Fibonacci series to convert km to miles. Let’s start easy by reprinting the Fibonacci series we had above:

1, 1, 2, 3, 5, 8, 13, 21, 34, 55

If we want to know how many miles are in 13 km, we find 13 on the series and then look for the previous Fibonacci number, which is 8. So there are about 8 miles in 13 km. And if we measure it, we see that 13 km is roughly 8.08 miles.

But what if we want to know how to convert a number that is not part of the Fibonacci series? Well, it turns out that you can add up Fibonacci numbers to make other numbers. So suppose we want to know how many miles are in 20 km. What you do is start with the closest Fibonacci number that is smaller than the number you’re looking for. We see in this case that that would be the number 13.

So keep 13 in mind. Now if you subtract 13 from 20, you’re left with 7. Let’s find the closest Fibonacci number smaller than 7, and that’s 5. So keep 5 in mind too. Finally, if we subtract 5 from 7, we’re left with 2, which is itself a Fibonacci number. So we end with 2.

So we’ve pulled out 13, 5, and 2. And if you’ll notice, 13 + 5 + 2 = 20, our original number. So 20 is composed of those three Fibonacci numbers. What we do to convert it to miles, then, is to find the next lowest Fibonacci number for each of those composite numbers, and add them together. So the next smallest from 13 is 8, the next smallest from 5 is 3, and the next smallest from 2 is 1. 8 + 3 + 1 = 12.

So there are about 12 miles in 20 km. And by measurement, we see that 20 km is actually about 12.4 miles, so we’re pretty close.

Now you may be wondering how the above works. Well, we know that the ratio between Fibonacci numbers is the golden ratio, and the ratio between miles and km is also close to the golden ratio. This means that so long as we can express the ratio of any number as a sum of Fibonacci numbers, we can use the previous “trick” to convert them.

To demonstrate how this works, let’s use a simpler ratio: 1/2. Suppose we wanted to know what half of 20 is. Obviously, we know that 20/2 = 10. But we can express 20 as 8 + 12 too. If we then take half of each of those numbers, we get 4 +6. 4 + 6 = 10, which is identical to 20/2. Or suppose we expressed 20 as 18 + 2. Half of 18 = 9, and half of 2 = 1. 9 + 1 = 10.

Because the ratio is the same, then no matter how you compose 20, dividing each of those numbers by the same ratio before you add them together is equivalent to finding the value of the original number divided by that ratio. So the same thing happens with Fibonacci numbers, except the ratio is the golden ratio instead of a half. Therefore, if we can compose a number as the sums of Fibonacci numbers (and if I am not mistaken, I believe all natural numbers can be expressed as the sums of Fibonacci numbers), then we can use the same technique as shown above to find a conversion between km and miles.

Now I should point out that while there are many things in nature that seem to use the golden ratio, the fact that the relationship between km and miles is close to the golden ratio is actually a matter of serendipity rather than due to some natural law of the golden ratio. Apparently, the mile was defined by the English Parliament in 1592 as being 1760 yards. The survey mile was derived as being 8 furlongs (each furlong being 10 chains, each chain being 4 rods, and each rod being 25 links—yeah, you figure it out). There is no intrinsic pattern or order to any of these gradations, hence the continual demand in science to use the metric system.

A meter, on the other hand, was originally defined as the length of a pendulum with a half-period of 1 second. It was later changed to being 1/1000000 of the distance between the North Pole and the equator. In 1983, the definition was changed so that a meter is now officially the distance light travels through a vacuum in 1/299792458 seconds. This number was formed by using an updated version of the previous definition of a meter and measuring the speed of light as 299792458 meters per second; but it has now become the benchmark itself.

So these two methods, one complete arbitrary and seemingly random, and the other apparently strict measurements of distance covered through time, somehow happened to form a ratio fairly close to the golden ratio.

Since a commenter recently noted that Steve’s been writing almost all of the Triablogue posts of late, I figure I can post this one on the T-Blog even though I’m not quite sure there’s any practical apologetic use for it. On the other hand, it’s stuff that I find “wicked kewl” and therefore is interesting to me. But it’ll have a bit of math in it, so if you don’t like that, well I’m sure Steve will write something new shortly :-)

One of the questions that cosmologists have pondered is whether the universe is open or closed. An open universe would extend infinitely in all directions, whereas a closed universe would have a “boundary.” However, even a closed universe could still be infinite. If space was curved in such a manner that, just like you could always travel East on Earth and return to the point you started from, in the universe you could always pick a direction and travel long enough and you’d return to your starting point. In other words, you could travel infinitely in one direction yet always return to your starting point (this would assume space was curved in the fourth, or higher, dimension that we cannot physically see).

I have to admit that I have a strange attraction to these kinds of loops. I don’t know why, but they appear “pleasing” to me. And therefore I find it no surprise that I’ve discovered one such loop within numbers themselves. In other words, just as we could say that the universe is infinite yet closed because it loops back (assuming that theory is correct, I must add—by far this is not proven!), I say that numbers themselves are infinite and yet closed because they loop back on themselves too.

For a simple proof (simple in that it requires nothing more than algebra), consider the following.

1. The number 1 (one) is that number which has no factors other than 1.

This can be restated as:

1′. If a number n has only 1 as a factor, then n = 1.

This seems fairly straightforward to me, yet by the end of this you’ll see why it might be tempting to deny the above.

Now we need to give one other tidbit of information. I’ll explain it below (and note that because we are dealing with factors, by definition we’re only considering positive values and whole numbers, so all the numbers below are positive integers):

2. Let c be a factor of w.

3. Since c is a factor of w, the next integer greater than w that c can likewise be a factor of is w + c.

Since many people don’t like thinking with letters instead of numbers, let me give a concrete example. Let’s say that c = 7 and w = 21. 7 is a factor of 21, so (2) above is satisfied. (3) states that if 7 is a factor of 21, the next number greater than 21 that 7 could be a factor of would be 21 + 7, or 28. And this is obvious because 22, 23, 24, 25, 26, and 27 cannot have 7 as a factor. Indeed, (3) is really nothing more than restating the definition of a factor.

Now let my proof begin in earnest:

4. Let x be the product of all positive integers. That is x = 1 x 2 x 3 x 4 x … x infinity.

5. Since x is the product of all positive integers, then x has all positive integers as factors.

6. Let a be a factor of x.

7. The next number greater than a than will be a factor of x is x + a.

8. Consider x + 1.

9. Let a = 1.

10. a is a factor of x + 1 (per (7)).

11. Therefore, 1 is a factor of x + 1.

12. Let a be greater than 1.

13. a cannot be a factor of x + 1 because the next greatest number than x that a could be a factor of is x + a (per (7)), and a > 1 (per (12)).

14. Therefore, 1 is the only factor of x + 1 (per (11)).

15. Therefore, x + 1 = 1 (per (1′)).

16. If x + 1 = 1, then x = 0 (algebra).

17. But(!) x = 1 x 2 x 3 x 4 x … x infinity (per (4)).

18. Therefore, 1 x 2 x 3 x 4 x … x infinity = 0.

Now the way that I see it, there are one of two options that mathematicians can take here. Either we can simply rule that when x is 1 x 2 x 3 x 4 x … x infinity, then x + 1 is undefined (similar to the way that division by zero is undefined), or we can say that numbers themselves contain some sort of looping mechanism, wherein by the time you reach infinity (the infinity defined as the product of all positive integers), you “loop back” to zero.

You already know which way I’ll go because I like loops. :-) But there is more evidence. I think we can see the “loop back” when looking at a tangent graph. Since I don’t want to throw in Greek symbols here, assume that a is an angle: tan(a) = sin(a)/cos(a). So, whenever cos(a) = 0, tan(a) is undefined because of division by zero.

The tangent graph looks like this:

That’s with the classic orientation, where the origin (where the arms of the graph cross) is located at (0,0). You can tell that since the right-hand portion of the graph is running up toward infinity and the left-hand portion is running down toward negative infinity why there would be a sudden “jump” in the graph at pi/2 (since cos(pi/2) = 0). If the x value is just slightly less than pi/2, you have positive infinity, but if it’s just slightly more than pi/2 you have negative infinity.

Instead of assuming these things just go off to infinity, what happens if we assume that they “connect” at infinity and redraw the graph from that perspective? If I did it correctly (and since it’s late at night right now, I am subject to correction), you’d get something that looks like this:

For this graph, we’re looking at how it relates to infinity. Basically, what I did was assume that the graph “rolls over” at infinity, and made the horizontal axis the point where positive infinity and negative infinity intersect. In essence, you move the lower left to the upper right on the tangent graph and vice-versa. Naturally, the graph is horrifically distorted since it’s representing two infinities on the vertical axis—the lines would actually appear to be virtually synonymous with the vertical axis for most of the trip, with the hook out at the very end; but I think this is sufficient to at least give a faint picture. (Note: technically, the origin on this graph would still be undefined, since the origin in this view is the point where the division by zero takes place.)

In any case, note that this graph would continue in sequence, just like the tangent graph does. That means that you could print out a row of these figures. The interesting thing about them is that you can then take the top of the graph and “fold” it down so that the 0s appear on the same line (the graph would now be on a donut-shaped paper rather than a 2D screen). At this point, the line graphed would look continuous (bearing in mind that at the origin of each cross point (multiples of pi/2) the graph would still be undefined).

This would imply that the graph, represented flat on a 2D surface, takes on the characteristics of a bent 3D object. Though only two dimensions are present in the tangent graph, there is an assumed third dimension where the graph “rolls over” from positive to negative infinity. In this curved 3D representation, the graph no longer has an infinite jump from positive to negative infinity, but rather that jump is a mere point, more akin to switching from positive to negative numbers at 0.

In short, it would be a curved space of infinite length, curved in a higher dimension.

This might actually affect physics. If it is true that math on the number line itself assumes a higher dimension of curved “space” then one could question whether that means reality really is curved, or whether it means that our math will always make it appear to be curved regardless of what it really is. In other words, is the fact that the math involved in physics seems to indicate a curved universe the result of the way that the universe actually is, or is it because the only method by which we have of probing the universe on such levels is mathematically, and math itself is curved? To use an analogy, suppose you use a level and see that a board appears warped; is the board warped or is the level warped? If we define the level as being level, then the board is warped; but what if we begin to see evidence that the level itself shows a curve?

Being me can be somewhat fun, even if it is definitely somewhat weird. For example, I have the day off today because I’ll be heading up to Denver with my sister to pick up our parents from DIA since they’re back in the states for a month. Since I wasn’t working, and since I had some time to kill before heading off to Denver, I was reading a book. And then, right in the middle of a sentence, I suddenly had a thought about geometry. It’s hard for me to put into words what exactly the thought was, but after about thirty seconds I had come to a conclusion.

Namely, if you take an isosceles right triangle and get the hypotenuse, then you construct another isosceles right triangle with the base and arms equal to that hypotenuse, the hypotenuse of the second triangle will be twice the size of the base of your first triangle.

How many other people have that thought in the middle of a stinking novel?

In any case, since I’ve mentioned it here, I can go ahead and prove it to you just for fun. All you need to know is the Pythagorean theorem, which is a² + b² = c². Oh, and I suppose you should also know that in an isosceles right triangle, a = b. So for them, you can say 2a² = c².

So, if a = 1, then c = 2^1/2 (the square root is a number to the 1/2 power)

This follows from both equations, as you have:

1² + 1² = c²
1 + 1 = c²
2 = c²
2^1/2 = c

Or:

2(1²) = c²
2(1) = c²
2 = c²
2^1/2 = c

In any case, now we take 2^1/2 as the base of our second triangle. To keep the variables separate, I’ll call the second triangle 2x² = z², where x = 2^1/2. So:

2[(2^1/2)²] = z²
2(2) = z²
4 = z²
2 = z

So you can see that a = 1, z = 2. So z = 2a.

In any case, this works for all numbers, since we can show that by using variables instead of real numbers, as follows:

Take a triangle ABC where AB = BC, and take a triangle ACD, where AC = CD, then I say that AD = AB + BC.

Let AB be of the length a.
Therefore, BC is also of the length a.
Therefore, AB + BC is of the length 2a.

Also, therefore, AC is of the length (2a²)^1/2.

Which is also 2^1/2a since (xy)^1/2 = x^1/2y^1/2.

Since AC = CD, then CD = 2^1/2a

Therefore, AD² = (2^1/2a) ² + (2^1/2a) ²

AD² = 2a² + 2a²
AD² = 4a²
AD = [4a²]^1/2
AD = (4^1/2)(a²)^1/2
AD = 2a

Therefore, AD = AB + BC.
Q.E.D.

All that from reading a completely non-related novel.

Sometimes, I think it would be great if I could turn my brain off at will. You know, just stop thinking and float for a bit. This usually comes after I’ve spent the night tossing and turning trying to visualize the fourth dimension. Note: while I’m actually doing that, no way in the world do I want to turn my brain off! No, it’s only after I get up in the morning and drag my carcass off to work that the benefits of being able to turn my brain off exert themselves.

Oh, and if you’re trying to read between the lines, this did not occur last night, although it has in the past. Instead, it happened after I picked up my lunch at Subway this afternoon and started back to work. So it’s not an inconvenient time at least.

Here’s what I thought about. You remember the math stuff (I can see you roll your eyes, you know) about how zero = infinity and stuff like that? And you remember the cool nifty squares I made of numbers in various bases? Well, I think I’ve found a way to combine them.

As way of example, let me give you a base-12 square, where A = 10 and B = 11. Oh, and ou might want to look at this and this before you continue if you need a refresher as to what I am doing:

1 2 3 4 5 6 7 8 9 A B   Sum = 66
2 4 6 8 A 0 2 4 6 8 A   Sum = 60 (1 zero)
3 6 9 0 3 6 9 0 3 6 9   Sum = 54 (2 zeros)
4 8 0 4 8 0 4 8 0 4 8   Sum = 48 (3 zeros)
5 A 3 8 1 6 B 4 9 2 7   Sum = 66
6 0 6 0 6 0 6 0 6 0 6   Sum = 36 (5 zeros)
7 2 9 4 B 6 1 8 3 A 5   Sum = 66
8 4 0 8 4 0 8 4 0 8 4   Sum = 48 (3 zeros)
9 6 3 0 9 6 3 0 9 6 3   Sum = 54 (2 zeros)
A 8 6 4 2 0 A 8 6 4 2   Sum = 60 (1 zero)
B A 9 8 7 6 5 4 3 2 1   Sum = 66

Now, as before with base-10 math, if you give the zero an actual value (in this case, 6) then the sums add up to 66 per row in base-12. Oh, and if you’re wondering, the pattern seems to be this:

Take any even base, b. Then take the midpoint, as m = b/2. Then find m² + [(m – 1)m]. That will be what each row adds up to, if you assume a zero value = your m value.

So we show this in base 14. In base 14, b = 14, so m = 7. 7² = 49, while [(7 – 1)(7)] = 6 x 7 = 42. 42 + 49 = 91. We can test it by seeing that 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 +13 = 91 (this would be your first row if you constructed a box like the above, although it would look like 1 2 3 4 5 6 7 8 9 A B C D).

In any case, you can convert

m² + [(m-1)m] = 2m² – m

which is easier to use on a calculator.

In any case, look at what would happen if we included a zero:

1 2 3 4 5 6 7 8 9 A B 0  Sum = 66 (1 zero)
2 4 6 8 A 0 2 4 6 8 A 0  Sum = 60 (2 zeros)
3 6 9 0 3 6 9 0 3 6 9 0  Sum = 54 (3 zeros)
4 8 0 4 8 0 4 8 0 4 8 0  Sum = 48 (4 zeros)
5 A 3 8 1 6 B 4 9 2 7 0  Sum = 66 (1 zero)
6 0 6 0 6 0 6 0 6 0 6 0  Sum = 36 (6 zeros)
7 2 9 4 B 6 1 8 3 A 5 0  Sum = 66 (1 zero)
8 4 0 8 4 0 8 4 0 8 4 0  Sum = 48 (4 zeros)
9 6 3 0 9 6 3 0 9 6 3 0  Sum = 54 (3 zeros)
A 8 6 4 2 0 A 8 6 4 2 0  Sum = 60 (2 zeros)
B A 9 8 7 6 5 4 3 2 1 0  Sum = 66 (1 zero)
0 0 0 0 0 0 0 0 0 0 0 0  Sum = 0  (12 zeros)

Now, let’s add the value of 0 = 6 to the equation above:

1 2 3 4 5 6 7 8 9 A B 0  Sum = 72 (1 zero)
2 4 6 8 A 0 2 4 6 8 A 0  Sum = 72 (2 zeros)
3 6 9 0 3 6 9 0 3 6 9 0  Sum = 72 (3 zeros)
4 8 0 4 8 0 4 8 0 4 8 0  Sum = 72 (4 zeros)
5 A 3 8 1 6 B 4 9 2 7 0  Sum = 72 (1 zero)
6 0 6 0 6 0 6 0 6 0 6 0  Sum = 72 (6 zeros)
7 2 9 4 B 6 1 8 3 A 5 0  Sum = 72 (1 zero)
8 4 0 8 4 0 8 4 0 8 4 0  Sum = 72 (4 zeros)
9 6 3 0 9 6 3 0 9 6 3 0  Sum = 72 (3 zeros)
A 8 6 4 2 0 A 8 6 4 2 0  Sum = 72 (2 zeros)
B A 9 8 7 6 5 4 3 2 1 0  Sum = 72 (1 zero)
0 0 0 0 0 0 0 0 0 0 0 0  Sum = 72 (12 zeros)

And what is the relationship of m = 6 to the result of 72?

2m²
2(6² = 2(36) = 72.

In some way, it appears that because of the way the pattern works, the zero (which is where the pattern repeats) seems to take on the value of the midpoint of the pattern. In other words, zero doesn’t act like “nothing” in these patterns. Zero acts as if it has value, but the value comes not because of the digit itself, but because of the patterns that are formed.

Now here’s the thing. You can extend this out to infinity, at least as long as you’ve got an even infinity for your pattern. Of course, we’d quickly run out of digits to express our pattern, so we couldn’t make a physical box like we’ve done above. But if you have an infinite number base that’s even (when I have time later I may see how this works in odd bases too, but at the moment my lunch break is almost over), then the zero value in the patterns would seem to take on 1/2 infinity as its value.

Of course, this begs the question: does it really take on this value? Obviously in terms of pure math, we’d say, “of course not.” On the other hand, looking at the patterns above, it seems so elegant to get the rows all to the same value that it feels like there’s something to this notion.

In any case, I think it’s safe to agree that zero isn’t what we usually think it is.

As I came to work this morning, something dawned on me about the Factor Field. Long story short, the value I assigned for *! would actually be 0, since I had already established that *! = 0; and therefore, *! can’t be the place where infinity switches its sign.

But that’s okay, because I think I figured out where that switch would be anyway. To demonstrate this, I have to start with the fact that if *! = 0, as I showed in this post, then we are faced with what seems to be a contradiction. Numbers get larger and larger, yet at some point they have to switch to become smaller and smaller in order to get us back down to zero. And, in fact, this happens if you think about infinity switching signs.

So I thought to myself, Self, is there another place on the graph where we can extrapolate from something we see to form an analogy of what would happen at infinity? And I responded, Why, yes, Self, there is!

That’s because basically what we are looking for are the properties when x =1, 2, 3, 4, 5…infinity are all valid. So we can look at a place where some of these properties are valid and deduce what would happen if they were all valid. So I picked the graph at 420.

That’s because 420 has factors 1, 2, 3, 4, 5, 6 and 7 (it also has lots more, but this make a nice “spike” in the graph for us to look at). Here’s what it looks like in part:

Now here’s the important thing to examine: the radial arms. The radial arms match the spike that shoots out from the center in terms of length. They also go at a 45 degree angle (a slope of 1/1 and -1/1) from the spike at y = 420.

Why is that important? If we ignore everything after x = 7, the graph looks exactly the same at y = 420 as it does at y = 0:

So the value of y at the maximum point will be equivalent to the length of the radial arms, and the length of the spike—so it’s the infinity formed by adding 1 + 1 an infinite number of times.

This means that the value of *! needs an adjustment. While it is true the *! = 0 if we define *! as 1 x 2 x 3 x 4 … x infinity, that’s not the only infinite value that equals zero!. Consider for a minute something about even numbers. If 4 is a factor of a number, then 2 must also be a factor of that number. If 16 is a factor of a number, then 2, 4, and 8 are all factors too!

Suppose for a moment that we’re looking for the graph of a number that has 2, 4, 6 and 8 as factors. If we have 8 as a factor, then we must already have 2 and 4 as factors. That means that we only need to multiply 6 x 8 to get a number that has 2, 4, 6, and 8 as factors. 6 x 8 = 48, which does indeed have 2, 4, 6, and 8 as factors. Now it is still true that if we multiplied 2 x 4 x 6 x 8 we’d also have a number that contains 2, 4, 6, and 8 as factors (that number would be 384). But 384 is a lot larger than 48! If the key that we were searching for was the first time we got 2, 4, 6, and 8 as factors, it would happen at 48 and we’d never get to 384.

So that means that we’re not actually going to use the infinity of 1 x 2 x 3 x 4 … in our problem. We can throw out 2 no matter what, because any even number greater than 2 will automatically have 2 as a factor. That alone halves the size of the infinity we’re dealing with. In reality, the number we’re dealing with is simply the number that is made by multiplying the highest values of numbers close to infinity that are composed of all the other factors below infinity. That number is, of course, impossible to write down. But let’s call it m, for maximum. m = 0, for the same reasons that *! = 0. Namely, m has all the factors of all the numbers, so the graph of m + 1 looks exactly like the graph of 0 + 1, so m + 1 = 1, and therefore m = 0.

However, m < *! in terms of the size of the infinity, since 1 x 2 x 3…etc. is going to be way larger than simply multiplying the highest numbers that contain all the lesser factors together! Furthermore, it would place us in the position where *! falls outside the range of the Factor Field. I think this is just Gödel making his appearance, so I’m prepared to dismiss it—but of course that may not be the rigorous mathematical thing to do!

Now if the distance from 0 to m is one oscillation, then the sign switch of infinity will occur at a distance of m/2. That’s because you go out m/2 distance, then you return m/2 distance. Let’s call m/2 by the variable M.

Let’s try to visualize what’s going on. Imagine the graph that goes up from y = 0 somehow meeting the graph that goes down from y = 0. At the point they meet, infinity switches signs. The numbers are getting larger and larger as the graph goes up; then it hits the merge point (at the sum of all whole numbers) and instantly we go from +infinity to –infinity—exactly as what occurs on the tangent graph. Then the points fall back down (or rather, still increase but now from their negative state) to the value of zero, where they switch signs and go back up toward infinity.

Now for why I think this M point is where the sign of infinity switches. Again, think of the graph at y =0. We move up in the positive values to reach infinity at y = M. But at y = M + 1, the graph has inverted. If M – 1 is positive infinity – 1, then M + 1 is negative infinity + 1. This is exactly what you’d expect, because M + 1 looks exactly the same as the line you’d get at negative infinity when the line reaches the negative value of M – 1.

I maintain that this is exactly what happens at the tangent graph, and the reason that we cannot actually graph it when cos x = 0 is because M is simultaneously positive and negative, just as zero is simultaneously positive and negative.

Just some quick notes (more for me to keep track of things to think about, rather than me trying to prove anything here). I think that given my previous two posts, -*! corresponds to the positive number line while +*! corresponds to the negative number line. That is, since zero is a reflecting point, and *! Is functionally equivalent to 0, then *! is also a reflecting point. However, if you try to picture this mentally, in order to keep positive integers from being cancelled out by the graph created at *!, you’d have to invert the signs in one of them.

Secondly, where functions are undefined (such as the tangent function wherever cos x = 0), I think that’s where the sign switches at the infinity mark. In other words, just as hitting zero on a number line switches our sign, so hitting *! switches the sign. This is sort of like saying the function actually is continuous, but in a different dimension that we cannot draw on the 2D grid. In other words, if we flip it and instead graph it from the x-axis crossing y at *!, then we’d see the line go through the point at *! and we’d be referring to the positive and negative zero, rather than the positive and negative infinity, and we’d be saying that the function is undefined at 1/n as n-> infinity (instead of how it is now, when it’s as n -> 0).

In other words, I think that the only reason these functions are considered undefined there is that we cannot visualize the two infinities meeting. Except that we can once we realize that it would look exactly like the zero line. We still couldn’t draw it, but we could at least visualize what it ought to look like, at least as far as we can mentally think of any infinite.