Wednesday, April 19, 2006

Quantum Mechanics for Dummies

I have been requested to produce an article on quantum mechanics which is accessible to the interested lay person, and so I oblige. To begin with, let's run through a brief history of quantum mechanics. The first evidence that could not be explained by Newtonian physics were the solar spectral lines. In 1814 Joseph von Fraunhofer noticed a number of dark lines in the solar spectrum (produced by sending sunlight through a prism or a diffraction grating). He gave each line a name such as C (produced by hydrogen) or D1 (produced by sodium) but he could produce no physical explanation for these dark lines. Each line represents reduced energy being emitted by the sun at a specific wavelength. These solar spectral lines were soon discovered in the light emitted by other stars but they remained totally unexplained for almost a century.

In 1900 the German physicist Max Planck hypothesized that the quanta (i.e., individual packets of energy) released by a hot object could best be explained if they had discrete energy values. He proposed the now-famous Planck equation:

E = n * h * nu

where E is the energy of the quantum, n is a postive integer (e.g., 1, 2, 3, etc.), h is the famous Planck's constant (6.626E-34 joule-seconds), and nu is the frequency of the light in Hertz (cycles per second). Thus, an individual photon (i.e., quantum) of light can have an energy of h*nu, 2*h*nu, 3*h*nu, etc. but not 1.5*h*nu, 2.1*h*nu, etc. The energy of the photon is said to be quantized and the new branch of physics introduced was called quantum mechanics (based upon the classification of the old branch of physics as classical mechanics or Newtonian mechanics).

In 1905 (the same year that he published his Special Theory of Relativity) Albert Einstein presented evidence that the photoelectric effect (i.e., the ejection of electrons from atoms via light) involved discrete particles of light which he named photons. The photons were the same as Planck's quanta.

In 1913 Niels Bohr showed how the new quantum theory could explain the solar spectral lines which had puzzled Fraunhofer almost a century before. Bohr constructed a quantum model of the hydrogen atom which still has explanatory power even today. In the Bohr atomic model the electrons orbit the nucleus (i.e., a single proton for hydrogen) in discrete circular orbits. The lowest orbit has quantum number N = 1, the second lowest orbit has quantum number N = 2, and so forth. The higher the N number the greater the energy the electron possesses. When an electron falls from a higher orbit to a lower orbit it produces a photon of light whose energy is the energy difference in the orbits. An electron can climb to a higher energy orbit by absorbing a photon whose energy equals the energy difference in the orbits. Thus, the Bohr model could explain discrete energies (i.e., wavelengths) for emitted or absorbed light and thus the solar spectral lines.

Bohr also postulated what he called the Correspondence Principle which said that in the limit as N goes to infinity the predictions of quantum theory and classical theory must agree. Thus, classical physics is nothing but a derivation of quantum physics for large quantum numbers. Planck, Einstein, and Bohr produced what is known as the Old Quantum Mechanics which was a complete theory by the year 1915. But it was soon to be eclipsed by the New Quantum Mechanics in a few short years. I will have more to say about the New Quantum Mechanics in a future post.

The Twin "Paradox"

Let's consider the relativistic space trip to Alpha Centauri specified in the previous post, but now let's make it a roundtrip there and back. According to my previous calculations the total roundtrip should take about 12 years as measured on the Earth and about 7 years as measured on the spaceship. Let's assume there are two identical twins. One stays home and the other one is an astronaut on such a spaceship. When the spaceship returns to Earth the twin who was the astronaut is now 5 years younger than the twin who remained on Earth.

But Einstein also says in his Special Theory of Relativity that there are no privileged reference frames. Thus, the laws of physics are the same anywhere in the universe. Therefore, if we take the point of view of the twin who is the astronaut, then it is the Earth which has moved away and returned. The Earth is moving relative to the spaceship. Therefore it should be the twin on the Earth who is 5 years younger when the Earth returns to the spaceship.

Well, both twins cannot be 5 years younger than the other. Only one of them can be younger than the other one. This is an apparent paradox which stumped many physicists at the beginning of the 20th century. How can this paradox be resolved?

The paradox assumes that the situation of the spaceship and the Earth are identical. Are they in reality? Well actually, no. Although from the point of view of the spaceship the Earth appears to move away there is one crucial difference - the spaceship is accelerating but the Earth is not (actually the Earth is accelerating in its orbit around the Sun but this acceleration is negligible compared to the acceleration due to gravity at the Earth's surface - about 0.0006 g's). The time dilation effect (i.e., slowing down in time) applies only to the object that is accelerating. This explains why it is the astronaut twin who returns 5 years younger than the Earth-bound twin and not vice versa.

Actually, the concept that velocity is relative but that acceleration is absolute led Einstein to his next great theory - the General Theory of Relativity published in 1915.

Java Program for Relativistic Space Travel

Here is the Java source code for the program mentioned in the previous post concerning relativistic space travel. Usage of the program is as follows:

java RelativisticTravel distly

where distly is the total trip distance in light-years.

Enjoy!

---------------------------------------------------------------------------------------------
import java.io.FileWriter;import java.io.IOException;import java.text.DecimalFormat;import java.util.ArrayList;import java.util.List;
/** * Class for computing the acceleration, speed, and distance of a trip under constant * thrust assuming relativistic effects. It is assumed that a constant thrust per * kilogram acts on the spaceship during the trip. Up until the midpoint of the trip * the spaceship is accelerating away from Earth towards its destination (i.e., the * rocket nozzles are pointed towards the Earth). After the midpoint of the trip the * spaceship is decelerating (i.e., the rocket nozzles are pointed towards the * destination). The spaceship arrives at the destination with zero speed. * @author Tom Marking */public class RelativisticTravel{ // Declare the application object private static RelativisticTravel theApp; // Declare the speed of light in meters per second private static final double SPEED_OF_LIGHT = 2.99792E8; // Declare the acceleration due to gravity at the Earth's surface in // meters per second per second (i.e., 1g) private static final double ACCEL_GRAVITY = 9.80665; // Declare the number of seconds per minute private static final double SECONDS_PER_MINUTE = 60.0;
// Declare the number of minutes per hour private static final double MINUTES_PER_HOUR = 60.0;
// Declare the number of hours per day private static final double HOURS_PER_DAY = 24.0;
// Declare the number of days per year private static final double DAYS_PER_YEAR = 365.2422;
// Compute the number of seconds per hour private static final double SECONDS_PER_HOUR = SECONDS_PER_MINUTE*MINUTES_PER_HOUR;
// Compute the number of seconds per day private static final double SECONDS_PER_DAY = SECONDS_PER_HOUR*HOURS_PER_DAY;
// Compute the number of seconds per year private static final double SECONDS_PER_YEAR = SECONDS_PER_DAY*DAYS_PER_YEAR;
// Compute the number of meters per light-year private static final double METERS_PER_LIGHT_YEAR = SPEED_OF_LIGHT*SECONDS_PER_YEAR;
// Set the time step equal to 1 day private static final double TIME_STEP = 1.0*SECONDS_PER_DAY;
// Set the thrust per kilogram equal to 1g private static final double THRUST_PER_KILOGRAM = 1.0*ACCEL_GRAVITY;
// Set the initial time, speed, and initial distance equals to 0 private static final double INITIAL_TIME = 0.0; private static final double INITIAL_SPEED = 0.0; private static final double INITIAL_DISTANCE = 0.0;
// Declare the new line character private static final String NEW_LINE = "\r\n";
/** * main program * @param args command line arguments */ public static void main(String[] args) { if (args.length != 1) { System.out.println("Usage: java RelativisticTravel "); System.out.println("Where is the trip distance in light-years"); return; }
// The command line argument is the total distance of the trip in // light-years double distTripLy = Double.parseDouble(args[0]); if (distTripLy <= 0.0) { System.out.println("Error in the distance of the trip: " + distTripLy); return; } // Run the application theApp = new RelativisticTravel(); theApp.run(distTripLy); } /** * Run the application * @param distTripLy total distance of the trip in light-years */ private void run(double distTripLy) { // Declare the list of spaceship parameters List paramList = new ArrayList(); // Initialize the time measured on Earth double timeEarth = INITIAL_TIME; // Initialize the time measured on the spaceship double timeSpaceship = INITIAL_TIME; // Initialize the acceleration of the spaceship double accel = THRUST_PER_KILOGRAM; // Initialize the speed of the spaceship double oldSpeed = INITIAL_SPEED; double newSpeed = INITIAL_SPEED; // Initialize the distance that the spaceship has travelled double dist = INITIAL_DISTANCE; // Initialize the time dilation factor double gamma = 1.0; // Save the initial parameters double timeEarthYr = timeEarth/SECONDS_PER_YEAR; double timeSpaceshipYr = timeSpaceship/SECONDS_PER_YEAR; double accelGs = accel/ACCEL_GRAVITY; double relSpeed = newSpeed/SPEED_OF_LIGHT; double distLy = dist/METERS_PER_LIGHT_YEAR; Param param = new Param(timeEarthYr, timeSpaceshipYr, accelGs, relSpeed, distLy); paramList.add(param); // Compute the skip factor for saving parameters int skipFactor = (int)Math.floor(10.0*distTripLy); int iValue = 1; double lastTimeEarth = 0.0; // Accelerate up until the midpoint of the trip while (dist/METERS_PER_LIGHT_YEAR <= 0.5*distTripLy) { // Compute the time dilation factor gamma = getGamma(oldSpeed); // Increment the time as measured on Earth timeEarth += TIME_STEP; // Increment the time as measured on the spaceship (include the time // dilation factor) timeSpaceship += (TIME_STEP/gamma); // Compute the acceleration of the spaceship accel = THRUST_PER_KILOGRAM / (gamma*gamma*gamma); // Compute the new speed of the spaceship newSpeed = oldSpeed + accel*TIME_STEP; // Increment the distance that the spaceship has travelled dist += (0.5*(oldSpeed + newSpeed)*TIME_STEP); // Let the old speed be the new speed oldSpeed = newSpeed; iValue++; // Do not save every set of values if (iValue % skipFactor == 0) { // Save the current parameters for the first half of the trip lastTimeEarth = timeEarth; timeEarthYr = timeEarth/SECONDS_PER_YEAR; timeSpaceshipYr = timeSpaceship/SECONDS_PER_YEAR; accelGs = accel/ACCEL_GRAVITY; relSpeed = newSpeed/SPEED_OF_LIGHT; distLy = dist/METERS_PER_LIGHT_YEAR; param = new Param(timeEarthYr, timeSpaceshipYr, accelGs, relSpeed, distLy); paramList.add(param); } } if (timeEarth > lastTimeEarth) { // Save the midpoint of the trip timeEarthYr = timeEarth/SECONDS_PER_YEAR; timeSpaceshipYr = timeSpaceship/SECONDS_PER_YEAR; accelGs = accel/ACCEL_GRAVITY; relSpeed = newSpeed/SPEED_OF_LIGHT; distLy = dist/METERS_PER_LIGHT_YEAR; param = new Param(timeEarthYr, timeSpaceshipYr, accelGs, relSpeed, distLy); paramList.add(param); }
// Compute the parameters for the midpoint of the trip int indexMid = paramList.size() - 1; Param paramMid = (Param)paramList.get(indexMid); double timeEarthYrMid = paramMid.timeEarthYear; double timeSpaceshipYrMid = paramMid.timeSpaceshipYear; double distLyMid = paramMid.distanceLy; // Use the parameters for the first half of the trip to compute the parameters // for the second half of the trip for (int index = indexMid-1; index >= 0; index--) { Param param1stHalf = (Param)paramList.get(index); timeEarthYr = timeEarthYrMid + (timeEarthYrMid - param1stHalf.timeEarthYear); timeSpaceshipYr = timeSpaceshipYrMid + (timeSpaceshipYrMid - param1stHalf.timeSpaceshipYear); accelGs = -1.0*param1stHalf.accelerGs; relSpeed = param1stHalf.relativeSpeed; distLy = distLyMid + (distLyMid - param1stHalf.distanceLy); param = new Param(timeEarthYr, timeSpaceshipYr, accelGs, relSpeed, distLy); paramList.add(param); } // Write the parameters for the relativistic trip to an output file outputParam(paramList, distTripLy); } /** * Get the time dilation factor (i.e., gamma) * @param speed speed in meters per second * @return double time dilation factor */ private double getGamma(double speed) { double beta = speed/SPEED_OF_LIGHT; double gamma = 1.0 / Math.sqrt(1.0 - beta*beta); return gamma; } /** * Write the parameters for the relativistic trip to a file * @param paramList list of spaceship parameters * @param distTripLy total distance of the trip in light-years */ private void outputParam(List paramList, double distTripLy) { // Set up the decimal formatters DecimalFormat formatter1 = new DecimalFormat("#,###,##0.0000"); DecimalFormat formatter2 = new DecimalFormat("0.0000000000");
// Set the name of the output file String outFile = "RelativisticTravel.txt";
try { // Open the output file for writing FileWriter fw = new FileWriter(outFile);
// Write out the header information String outLine = "Relativistic trip under constant thrust"; System.out.println(outLine); fw.write(outLine + NEW_LINE); outLine = "During 1st half of trip the thrust vector is towards destination (acceleration)"; System.out.println(outLine); fw.write(outLine + NEW_LINE); outLine = "During 2nd half of trip the thrust vector is towards Earth (deceleration)"; System.out.println(outLine); fw.write(outLine + NEW_LINE); String sThrustPerKg = formatter1.format(THRUST_PER_KILOGRAM); outLine = "Thrust per kilogram = " + sThrustPerKg + " newtons"; System.out.println(outLine); fw.write(outLine + NEW_LINE); String sDistTripLy = formatter1.format(distTripLy); outLine = "Total distance of trip = " + sDistTripLy + " light-years"; System.out.println(outLine + NEW_LINE); fw.write(outLine + NEW_LINE + NEW_LINE); outLine = "Earth time\tSpaceship time\tAcceleration\t\tSpeed\t\t\tDistance"; fw.write(outLine + NEW_LINE); outLine = "(years) \t(years) "; fw.write(outLine + NEW_LINE); outLine = "------------\t--------------\t--------------\t\t--------------\t\t---------------"; fw.write(outLine + NEW_LINE);
// Compute the size of the list of parameters int nSize = paramList.size(); // Compute the midpoint of the trip int iMid = nSize/2; Param paramMid = (Param)paramList.get(iMid);
String sTimeEarthYr = null; String sTimeSpaceshipYr = null; String sAccelGs = null; String sRelSpeed = null; String sDistLy = null;
// Loop over the spaceship parameters for (int i = 0; i < nSize; i++) { // Get the current spaceship parameters Param param = (Param)paramList.get(i); double timeEarthYr = param.timeEarthYear; double timeSpaceshipYr = param.timeSpaceshipYear; double accelGs = param.accelerGs; double relSpeed = param.relativeSpeed; double distLy = param.distanceLy; // Convert the current spaceship parameters into strings sTimeEarthYr = formatter1.format(timeEarthYr); sTimeSpaceshipYr = formatter1.format(timeSpaceshipYr); sAccelGs = formatter2.format(accelGs); sRelSpeed = formatter2.format(relSpeed); sDistLy = formatter1.format(distLy);
// Write the current spaceship parameters to the output file outLine = sTimeEarthYr + "\t\t" + sTimeSpaceshipYr + "\t\t" + sAccelGs + " g\t\t" + sRelSpeed + " c\t\t" + sDistLy + " ly"; fw.write(outLine + NEW_LINE); }
// Write out the summary information outLine = "Total trip duration as measured on Earth = " + sTimeEarthYr + " years"; System.out.println(outLine); fw.write(NEW_LINE + outLine + NEW_LINE); outLine = "Total trip duration as measured on the spaceship = " + sTimeSpaceshipYr + " years"; System.out.println(outLine); fw.write(outLine + NEW_LINE); String sMaxRelSpeed = formatter2.format(paramMid.relativeSpeed); outLine = "Maximum speed during trip (achieved at midpoint) = " + sMaxRelSpeed + " c"; System.out.println(outLine); fw.write(outLine + NEW_LINE);
// Close the output file fw.flush(); fw.close(); } catch (IOException e) { System.out.println("Error getting file writer for file = " + outFile); } }
/** * This inner class is used to store the parameters of the spaceship at * any given point during the relativistic trip * @author Tom Marking */ public class Param { public double timeEarthYear; public double timeSpaceshipYear; public double accelerGs; public double relativeSpeed; public double distanceLy;
/** * Constructor * @param timeEarthYr time measured on Earth in years * @param timeSpaceshipYr time measured on the spaceship in years * @param accelGs acceleration in g's * @param relSpeed speed divided by the speed of light * @param distLy distance travelled by the spaceship in years */ Param(double timeEarthYr, double timeSpaceshipYr, double accelGs, double relSpeed, double distLy) { timeEarthYear = timeEarthYr; timeSpaceshipYear = timeSpaceshipYr; accelerGs = accelGs; relativeSpeed = relSpeed; distanceLy = distLy; } }}

Sunday, April 16, 2006

Relativistic Space Travel

One of the common ideas that the general public knows of Albert Einstein's Special Theory of Relativity (published in 1905) is the prohibition against travelling faster than light. This seems to be widely accepted by society at large. But what does it actually mean to say that it is impossible to travel faster than the speed of light? In this brief article I will attempt to show that the truth of this assertion depends entirely on your point of view.

One of the things that most people do not appreciate is that Einstein introduced the concept of time dilation in the same paper in which the prohibition against faster-than-light travel was introduced. Time dilation in effect is a mechanism which allows us to beat the faster-than-light restriction, but only for those brave souls who actually travel. Let me give an example.

The time dilation factor is known as gamma. It is defined as follows:

gamma = 1 / sqrt(1 - (v/c)*(v/c))

where v is velocity and c is the speed of light in a vacuum (300 million meters per second). Now let's say that you have a spaceship that is travelling at 90 percent of the speed of light (270 million meters per second). Gamma is then equal to 2.29. What does a time dilation factor of 2.29 mean? It means that for every 229 seconds which elapse on a clock back on Earth only 100 seconds will elapse on a clock on the spaceship. Thus, time slows down on the spaceship relative to Earth. Some early objections to Einstein's theory focused on what was thought to be a paradox concerning time dilation. This is the so called Twin Paradox. I will have more to say about it in a future posting.

Another equation I'd like to introduce is this one:

a = F / (gamma*gamma*gamma*m)

where a is the acceleration of the spaceship, F is the force (or thrust) acting on the spaceship, and m is the rest mass of the spaceship. Now let's imagine a relativistic space trip to the nearest star, Alpha Centauri, 4.3 light-years away. Assume that a constant force of 9.8 newtons is applied to the spaceship per kilogram of mass. In other words, if the spaceship weighs 100,000 kilograms then the spaceship produces a constant thrust of 980,000 newtons. Also, assume that for the first half of the trip (until the distance is 2.15 light-years from Earth) the force vector is pointing towards Alpha Centauri. This will cause acceleration to occur during the first half of the trip. Once the midpoint of the trip is reached the spaceship is turned 180 degrees and the force vector points towards Earth. This will cause decleration to occur during the second half of the trip.

Why was the special number of 9.8 newtons per kilogram chosen for this example? Because it implies that the initial acceleration of the spaceship is 9.8 meters per second per second (or 1g). Thus our astronauts inside such a spaceship will experience the same gravitational environment as the surface of the Earth (at least at the beginning and the end of the trip).

I have written a simple Java program to compute the various parameters at each stage of the trip. Here are the results:

t-Earth t-Space Accel Speed Distance
(yr) (yr)
------- -------- -------- -------- ---------
0.0000 0.0000 1.000g 0.000c 0.0000 ly
0.1150 0.1147 0.980g 0.117c 0.0068 ly
0.2327 0.2306 0.920g 0.233c 0.0276 ly
0.3505 0.3433 0.833g 0.340c 0.0615 ly
0.4682 0.4518 0.731g 0.435c 0.1073 ly
0.5859 0.5552 0.628g 0.517c 0.1635 ly
0.7036 0.6532 0.531g 0.588c 0.2287 ly
0.8214 0.7458 0.444g 0.647c 0.3016 ly
0.9391 0.8329 0.370g 0.696c 0.3807 ly
1.0568 0.9149 0.309g 0.737c 0.4652 ly
1.1746 0.9921 0.257g 0.771c 0.5542 ly
1.2923 1.0648 0.215g 0.800c 0.6468 ly
1.4100 1.1334 0.181g 0.824c 0.7425 ly
1.5278 1.1982 0.153g 0.844c 0.8408 ly
1.6455 1.2595 0.130g 0.862c 0.9413 ly
1.7632 1.3177 0.111g 0.876c 1.0437 ly
1.8809 1.3729 0.095g 0.889c 1.1477 ly
1.9987 1.4255 0.082g 0.900c 1.2531 ly
2.1164 1.4756 0.072g 0.909c 1.3596 ly
2.2341 1.5234 0.062g 0.917c 1.4672 ly
2.3519 1.5692 0.055g 0.924c 1.5756 ly
2.4696 1.6131 0.048g 0.931c 1.6849 ly
2.5873 1.6552 0.043g 0.936c 1.7949 ly
2.7051 1.6956 0.038g 0.941c 1.9054 ly
2.8228 1.7345 0.034g 0.946c 2.0166 ly
2.9405 1.7720 0.030g 0.949c 2.1282 ly
2.9652 1.7797 0.029g 0.950c 2.1516 ly
2.9898 1.7873 -0.030g 0.949c 2.1750 ly
3.1075 1.8248 -0.034g 0.946c 2.2866 ly
3.2253 1.8637 -0.038g 0.941c 2.3977 ly
3.3430 1.9042 -0.043g 0.936c 2.5083 ly
3.4607 1.9462 -0.048g 0.931c 2.6183 ly
3.5784 1.9901 -0.055g 0.924c 2.7275 ly
3.6962 2.0359 -0.062g 0.917c 2.8360 ly
3.8139 2.0838 -0.072g 0.909c 2.9436 ly
3.9316 2.1339 -0.082g 0.900c 3.0501 ly
4.0494 2.1864 -0.095g 0.889c 3.1555 ly
4.1671 2.2417 -0.111g 0.876c 3.2594 ly
4.2848 2.2998 -0.130g 0.862c 3.3618 ly
4.4026 2.3611 -0.153g 0.844c 3.4623 ly
4.5203 2.4259 -0.181g 0.824c 3.5607 ly
4.6380 2.4945 -0.215g 0.800c 3.6564 ly
4.7557 2.5672 -0.257g 0.771c 3.7490 ly
4.8735 2.6444 -0.309g 0.737c 3.8379 ly
4.9912 2.7264 -0.370g 0.696c 3.9224 ly
5.1089 2.8136 -0.444g 0.647c 4.0016 ly
5.2267 2.9061 -0.531g 0.588c 4.0744 ly
5.3444 3.0041 -0.628g 0.517c 4.1396 ly
5.4621 3.1076 -0.731g 0.435c 4.1959 ly
5.5799 3.2160 -0.833g 0.340c 4.2417 ly
5.6976 3.3288 -0.920g 0.233c 4.2756 ly
5.8153 3.4446 -0.980g 0.117c 4.2964 ly
5.9303 3.5593 -1.000g 0.000c 4.3032 ly

Thus we see that from the point of view of observers on Earth the trip of 4.3 light-years took 5.9303 years to complete for an average speed of 0.725 times the speed of light. But from the point of view of observers on the spaceship the trip took 3.5593 years to complete for an average speed of 1.208 times the speed of light. Thus, from the point of view of the passengers on the spaceship, they have been travelling FASTER THAN THE SPEED OF LIGHT!

The results are even more dramatic for longer distances as the following table suggests:

Distance t-Earth t-Spaceship
------------ ------------ ------------
10 ly 11.78 yr 4.85 yr
100 ly 101.92 yr 9.01 yr
1,000 ly 1,001.94 yr 13.44 yr
10,000 ly 10,001 yr 17.90 yr
30,000 ly 30,001 yr 20.03 yr

Thus, special relativity opens up our galaxy to exploration by human beings within a single lifetime of a person. A trip to our galaxy's center (i.e., 30,000 light-years away) can be accomplished in only 20 years from the point of view of the astronaut. Of course, from the point of view of the Earth 30,000 years will elapse before the spaceship arrives at the center of the Milky Way galaxy. There may be no one left on Earth to report the discoveries to!

--- Tom Marking, the Physics Guy