ArgueMax.com



This is the first of two mathematical proofs for the fact that the earth is round and spinning.

This proof is for both curvature and rotation.

To begin, let me say that, in summary – to describe this in a nut shell – this proof uses datum regarding the curvature of the earth and its rotation to adequately predict the time differential between watching sunset from ground level to seeing the time of sunset from a tower's observation deck.

This proof is in the form of a C++ program that I have written – it is to be posted online – and it is accompanied with documentation as well as this video.

In order to save time, in this presentation, we will call this proof: “The Tower Time”.

Like a recipe, here are the ingredients you need to determine “The Tower Time”:

1. The Latitude and Longitude of the location of the tower (I will explain why in a moment)

2. How high above sea level is the base of the tower.

3. The height of the highest observation deck. Notice this is not the same as the height at the top of the tower. You have to use the perspective of someone standing at the highest observation deck.

4. The next thing you need to do is take the latitude (which you got as the first item in this list) and use this graph to determine the radius of the earth, as best you can, based on the location of the tower's Latitude.

[pic]

1. You see, the earth is a little wider at the equator than the polar radius. This chart represents the size of the radius and how it changes based on the latitude that interests you. The curved line denoted as “R” is the earth's radius. All you have to do is pick the Latitude and follow it up to the curved line denoted as “R” and note the number of height of the intersection with this line by references the number of kilometers on the left. This gives you the earth's radius that you will use in the equation.

2.

[pic]

1. To illustrate this, using the position on earth of the CN Tower, we use this geodetic graph to determine that the radius of the earth where the CN Tower stands is about 6367.5 kilometers.

2.

Since the CN Tower stands 71.76 meters above sea level, the true radius we will use for our calculation will be 6,367,571.76 meters.

[pic]

1.

Another example is the Willis-Sears Tower in Chicago. The Earth's radius at this location is about 6,369,000 meters.

Once you have all this information, all you need to do is to input the numbers into the program and it will calculate what you need – and you will also find that the calculation accurately predicts reality. If by chance, you find that there is an error, measure more than one tower, the error percentage will match.

And now I will explain how the program works.

Imagine someone standing on the ground and alongside our tower. If the earth is round and spinning, they will see the sun set while the sun is still shining on the vast majority of the tower. And as the earth continues to rotate away from the sunlight, there will be a shadow from our planet earth creeping up the tower from the bottom up towards the top of the tower. Eventually, someone on the observation deck will see the sun set some time after our first person saw it.

Here is the geometry that explains how this time is determined.

[pic]

The circle represents the radius of the earth at the determined amount we just explained. The horizontal red line represents light barrier at the moment of sunset. The blue angled line represents the line on which the tower resides and the distance between the intersection point with the circle and the red line would be the height of that tower.

What we want to know is the equation for that (blue) line on which the tower resides.

Finding and understanding this assumes that you have a fundamental understanding of algebra, geometry and the x and y coordinate system. I am familiar with these things and, frankly, I love this stuff.

So, to continue an X and Y coordinate system is used to represent mathematical formulas. Some formulas are circles, some formulas are ellipses, some are parabolic and some are linear. Linear equations that intersect for origin of the matrix – in other words, point (0,0) – are of the form of “y equals some multiple times x” (y = Mx).

If there is no multiple, and so we have an equation of x = y, then we have a line like this:

[pic]

If the multiple is 2, in other words, y = 2x, then we have a line like this:

[pic]

If the multiple to the equation is one half, then the functional line will look like this:

[pic]

The quest is to find the right number to serve in a linear equation such that a line will form where the height of the tower up to the observation deck can be placed on the line such that this height will measure the distance between the line's intersection with the circle and the intersection of the horizontal line representative of the sun light barrier

After this linear equation is found, and I will describe how that is done shortly, what is required next is to determine the distance along the circle of the earth from the base of the tower to the point where someone would be standing at the intersection of the curve and the horizontal line representing the daylight barrier.

Then this segment is thought of a slice of the 24 hours by thinking of the whole circumference of the circle represents one rotation of the earth as if it was the face of a 24 hour clock. If you imagine this as a rotating circle, you can understand this progression of sun light as described at the beginning of this presentation.

And there you have it. This, in a nutshell, is how “The Tower Test” proves that we live on a spinning ball.

And now to explain how the mathematics are done.

There might be many different approaches to providing the necessary math to solve this. I assume there is an algebraic method using differential equations by working it out by solving for x and y to find the intersection point by using the two equations where one is the exponential polynomial from the circle and the other is the proper equation for the line. If you do it this way, you have to solve for x and y by manipulation the equality and substituting for x and y.

That is one way to do it. But I found this to be a fairly challenging route to go. So, instead I wrote a computer program to do all the number crunching in a one-of-a- kind trial-and-error process that narrows down what the linear equation would be in a unique process that is designed to make progressively better and better guesses through a large number of iterations.

Here is how it works. It starts with a user defined close guess for what the multiple for the linear equation should be. Then the program uses this in a mathematical formula for a line as we have discussed already here. If the resulting tower height that would rest on this line is greater than what we know the tower height to our observation deck should be, a new equation is tested but this time the number that represents the multiple in the equation is increased by a certain interval to give the new linear equation a steeper angle. Then the process is repeated. This process changes the equation for the line accordingly to try to get closer to where it is supposed to be to represent the line we want for the tower height. This continues again and again until the line of evaluation steps over where it should be and then the evaluated tower is too short instead of too tall. At this point our interval of change is reduced and we work back the other direction and this time the interval is used to reduce the size of the multiple. When we pass over where the tower should be again, we reduce the interval and repeat the process. At each pass over where the tower should be, the size of their interval is reduced and as this interval gets smaller and smaller we get closer and closer to finding the right linear equation on which our tower would be.

This trial-and-error is tedious and so that is why I utilized the power of computer software to do it. But it gets results and these results match what we find when we test this in reality.

The software only takes a fraction of a second to perform all of these described calculations. But for those accustomed to software development, I have made a demonstration where I have put some break points in the code and I have run the code through a debugger so that we can watch an example of the calculations being made. This is seen in the video portion of this proof.

And now we move on to the calculation for the actual time difference between what someone would see for the sunset on the ground versus what someone would see from an observation deck. This requires finding the distance – along the circumference of the circle – between the vertical line where the observer would be standing at ground zero and the intersection of the circle with the line that has now been determined by our process. And then what is required is to think of this segment as a slice of a proverbial pie chart as if it represented a time interval of a clock but in our example it would be the face of a 24 hour clock instead of a 12 hour clock.

Finding this distance requires some understanding of trigonometry. What we are going to do now is use trigonometry rules to determine the angle that we have. Explaining the fundamental concepts of trigonometry is beyond the scope of this documentation and presentation. Explaining high school mathematical concepts is not what this proof is required to do. If you are familiar with the laws of sine, cosine and tangent, you would know that it would be easy to determine this angle. All you have to do in order to get the angle of a line is to use the arc-tangent of x over y ( arctan(x/y) ) . This will give us the angle of the line in relation to a 90 degree angle. So, of course we will have to subtract from 90 to get our angle we need.

Then we have to convert this fraction of 360 degrees that we have determined into the same percentage of time on a 24 hour clock. This requires a bit of algebra.

Here is a description of these final steps:

1. In order to get our angle, we first take the multiple for the equation we have determined in y equals some number times x (y=Mx) and we get the arc-tangent of this. As an example, I will use the data that was determined for the CN Tower in Toronto Canada:

84.430937780135920 is the number the code determined for this.

The code then takes this number and runs the math function atan(84.430937780135920) to come up with the number 1.5589528808956008 radians.

2. The next step is to convert this number in radians to the number of degrees by multiplying it with 180 over the constant number pi (180 / pi) . In our example this gives us 89.321420535078829 degrees

3.

4. Of course, this is the number if the x axis was zero degrees. But we are using the 90 degree or the y axis as our zero mark and so we have to take this number and subtract it from 90 to get the proper degree. And so, in our example 0.67857946492117094 is the proper degree we will use.

5.

6. Now comes the fun part. And, like I said, this requires some fundamental understanding of algebra. First, we come up with a fraction that represents the portion of 360 degrees that equals our answer:

[pic]

2.

This fraction equates to the a fraction where the numerator is unknown and the denominator is the number of seconds in 24 hours – which is 86,400. This is our denominator and X – the unknown value that we are solving for – is our numerator:

[pic]

2. This gives us this equation:

[pic]

2.

Now all we have to do is solve for X. Explaining fundamental and rudimentary algebra is beyond (or below) the scope of this description and documentation. Taking the equation above, it is easy to solve for X like so:

[pic]

2.

3.

In our example, crunching this number to solve for X gives us 162.85907158108103 seconds. Dividing by 60 give us the number of minutes. In our example for the CN Tower, our result is:

2 minutes and 42 seconds for the CN Tower in Toronto, Canada.

I ran the program again using input variables for the Willis Tower in Chicago (formerly called “The Sears Tower”) :

// The Willis (Sears) Tower in Chicago seems to be standing right at sea level

// and the earth radius there is 6369000 meters

// The sky deck observation area is 477 meters.

The results of this is that the time difference between seeing the sun set by a view at ground level compared to seeing the sun set from the “sky deck” of the Willis / Sears Tower is 2 minutes and 47 seconds.

This makes sense because the height from the ground to the Chicago Willis Tower's sky deck is 477 meters whilst the height from the ground to the sky pod of the CN Tower is only 447 meters.

And reality reflects that this is spot on accurate. As best as I could, I called people who are associated with tourism and upkeep of these places and they have confirmed that these are accurate results.

The Source Code

The complete software source code in C++ for this proof can be found on GitHub at and anyone can download the whole software package for what is required to compile and run this proof.

The main C++ file of interest is “”

The version of the developer environment is completely free from Microsoft and anyone can get the development environment and compiler for free and build this code into executable software for themselves. To compile and run the program for yourself, you can download the Microsoft Visual Studio Community 2017 version at

For the sake of completeness. Here is the software presented here:

// TowerTest.cpp

//

#include "stdafx.h"

#include

#include

using namespace std;

// For the CN Tower, we use 6377571.76 as the earth radius.

// The CN Tower sky pod is 447

// The Willis (Sears) Tower in Chicago seems to be standing right at sea level

// and the earth radius there is 6369000 meters

// The sky deck observation area is 477 meters.

const int secondsInDay = 86400;

double dEarthRadius = 6369000; // or 6377571.76;

double dTestAngle = 20;

double ourheight = 477; // or 447;

bool bTowerGreater = true;

double pi = 3.141592653589793;

// y = 6270.14 equation for the solar plane

// 20x = y equation for the starting guess for the line for the tower

// So using algabraic substition

// x = 6270.14 / 20

double TowerLineEquationY(double y)

{

double dX = y / dTestAngle;

return dX;

}

double TowerLineEquationX(double X)

{

double dy = X * dTestAngle;

return dy;

}

double CircleIntersection(double x)

{

double dReturn = (dEarthRadius * dEarthRadius) - (x * x);

dReturn = sqrt(dReturn);

return dReturn;

}

double calculatetowerheight(double x1, double y1, double x2, double y2)

{

double aSquared = (x1 - x2);

aSquared = aSquared * aSquared;

double bSquared = (y1 - y2);

bSquared = bSquared * bSquared;

double dHypotenuse = sqrt(aSquared + bSquared);

return dHypotenuse;

}

bool CloseEnough(double y1, double y2)

{

double Test = (y1 + y2);

Test = Test / 2;

if (Test == y1)

return true;

if (Test == y2)

return true;

if (y1 < Test)

Test = Test - y1;

else if (y2 < Test)

Test = Test - y2;

Test = Test * 1000000;

if (Test < 1)

{

return true;

}

else

return false;

}

int main()

{

// input values:

/* double dEarthRadius = 6377571.76;

double dTestAngle = 20;

double ourheight = 447;

*/

/*

cout ourheight;

// for now, we will ommit the users ability to enter the test angle initial value, to make things simple.

*/

double dTowerHeight = 0.0;

double dLinearAngleDifferential = 1.0;

if (dTowerHeight != ourheight)

do

{

double y = dEarthRadius;

double x = TowerLineEquationY(dEarthRadius);

double y1 = y;

double y2 = CircleIntersection(x);

double dInterval = 10.0;

if (CloseEnough(y1, y2) == false)

do

{

if (y1 > y2)

do

{

x = x - dInterval;

y1 = TowerLineEquationX(x);

y2 = CircleIntersection(x);

if (y1 < y2)

{

if (dInterval > 0.000000001)

dInterval = (dInterval * 99) / 100;

}

} while ((y1 > y2) && (CloseEnough(y1, y2) == false));

if (y1 < y2)

do

{

x = x + dInterval;

y1 = TowerLineEquationX(x);

y2 = CircleIntersection(x);

if (y1 > y2)

{

if (dInterval > 0.000000001)

dInterval = (dInterval * 99) / 100;

}

// iTrimmer = (int)(y1 * 1000);

// y1 = (double)(y1 / 1000);

} while ((y1 < y2) && (CloseEnough(y1, y2) == false));

} while (CloseEnough (y1, y2) == false);

//now we find the length of our tower

dTowerHeight = calculatetowerheight(TowerLineEquationY(dEarthRadius), dEarthRadius, TowerLineEquationY(y2), y2);

if (dTowerHeight > ourheight)

{

// we need a steeper angle

dTestAngle = dTestAngle + dLinearAngleDifferential;

if (bTowerGreater == false)

{

// we have flipped to the other side of measurement

dLinearAngleDifferential = (dLinearAngleDifferential * 999) / 1000;

bTowerGreater = true;

}

}

if (dTowerHeight < ourheight)

{

dTestAngle = dTestAngle - dLinearAngleDifferential;

if (bTowerGreater == true)

{

// we have flipped to the other side of measurement

dLinearAngleDifferential = (dLinearAngleDifferential * 999) / 1000;

bTowerGreater = false;

}

}

} while (CloseEnough(dTowerHeight, ourheight) == false);

// this gives a results in radians

dTestAngle = atan(dTestAngle); // 84.430937780135920 for the CN Tower

// 1.5589528808956008 radians

// this converts it to degrees

dTestAngle = dTestAngle * 180 / pi;

// 89.321420535078829 degrees

// this gives us the number we really need:

dTestAngle = 90 - dTestAngle; //84.430937780135920;

// 0.67857946492117094 is the actual angle to use

// and now for the final calculations

dTestAngle = (dTestAngle * secondsInDay) / 360;

// at this point, or variable "dTestAngle" equals the number of seconds

if (dTestAngle > 60)

{

// if it is more than one minute

int minutes = dTestAngle / 60;

int seconds = (dTestAngle - minutes * 60);

cout ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download