An Application of Linear Function: Galileo’s Equations of Motion

Summary

Code

Executable on S2

Videos

For about 2000 years before Galileo Galilei, the most popular worldview was Aristotelian physics. Aristotle believed that objects naturally moved toward their “natural place” in the universe. For example, earth and water naturally moved downwards, while air and fire moved upwards. According to Aristotle, objects in motion require a force to keep them moving.

This all changed when Galilean physics, which emerged in the 16th and 17th centuries, rejected this Aristotelian view of motion. Galileo Galilei argued that objects in motion would stay in motion unless acted upon by an external force, in contrast to Aristotle’s idea that objects would naturally come to rest without a force acting upon them. This idea is known as the principle of inertia. This is later developed by Issac Newton into his first law of motion.

Galileo also discovered that objects of different masses fall at the same rate in a vacuum, whereas Aristotle believed that heavier objects would fall faster. In modern terminology, objects of different masses have the same acceleration due to the Earth’s gravity. This can be shown using Newton’s second law of motion.

Furthermore, Galileo’s work laid the groundwork for the development of modern physics by introducing the concept of the scientific method and emphasizing the importance of experimentation and observation. He was also instrumental in the development of the mathematical language of physics, which allowed for precise calculations and predictions about the behavior of objects in motion. Specifically, Galileo was the first person to describe an object’s motion in terms of space, time, velocity, and acceleration. We are going to discuss Galileo’s equations of motion in this topic.

Using Numbers to Measure Quantities

In order to study the motion of the ball rolling down a slope, we need to describe the ball’s properties using mathematics. We want to be able to precisely describe the ball’s position/space, time, speed in terms of quantities, and study the relationships among these numbers.

To precisely describe the states of the ball, we will need to assign numbers or quantities to the properties of the ball. The properties that we are interested in knowing are its position/space and speed in different time points.

Suppose initially at \(t = 0\), the ball is at position \(x_0\) with an initial speed of \(v_0\). After time \(t\), i.e., \(t\) units of time has passed, the ball is now at a new position of \(x_1\) with a new speed of \(v_1\). We want to understand the relationships between these quantities \(x_0\), \(x_1\), \(v_0\), \(v_1\) and \(t\).

Speed

First, let’s define what speed means. We measure speed as the distance traveled per unit time. To understand what this sentence means, we reckon that every physical quantity is measured in some unit. For instance, distance is usually measured in “meters”. For example, a rabbit runs for 5 meters, or 5 m for short. A “unit time” is one time unit of the unit that we choose to measure how much time has passed. For example, suppose we choose “hour” as the unit to measure time, then one unit time is one hour. Suppose we choose “minute” as the unit to measure time, the one unit time is one minute. The usual convention is that we measure time in “seconds”. To compute the speed of an object, we compute how much distance the object travels in one unit of time. Speed is dividing the distance traveled by the number of time units spent.

\(\text{speed}(v) = \frac{\text{distance}(d)}{\text{time}(t)} \tag{eq 1}\), or

The unit of speed is \(\text{meter/second}\) or simply \(\text{m/s}\).

For example, suppose a rabbit runs 10 meters in 2 seconds, his speed is therefore:

Rearranging the terms in \(\text{eq 1}\) above, we can write the distance traveled in time \(t\) by

\(\text{distance}(d) = \text{speed}(v) * \text{time}(t)\), or

\(d = v * t\).

This distance equation is a linear function in time \(t\).

For the rabbit above, the distance that it travels in 10 seconds is

\(d = v * t = 5\text{ m/s} * 10\text{ s} = 50\text{ m}\), i.e., 50 meters.

We can code up the distance function as follows.

// the distance function
fun distance(speed : Double, time : Double): Double {
    return speed * time;
}

In 2 seconds, the rabbit runs

distance(5.0, 2.0)

10.0

In 10 seconds, the rabbit runs

distance(5.0, 10.0)

50.0

This distance function has two parameters, speed and time. If we fix the speed, e.g., 5 m/s for the rabbit, then the new function has only one parameter, time.

The code is:

// the distance function for a constant speed
fun distance1(time : Double): Double {
    val v = 5.0; // 5 m/s
    val d = distance(v, time);
    return d;
}

distance1(2.0) // in 2 seconds

10.0

distance1(10.0) // in 10 seconds

50.0

To see or visualize how far the rabbit travels over time, we can plot the distance curve, distance vs. time, of the rabbit.

// plot the distance curve
%use plotly

val t = (0..10)

Plotly.plot {
    scatter {
        x.set(t)
        y.set(t.map { distance1(it.toDouble()) })
    }
}

It is clear that the distance function is a linear function. The graphical representation of it is a straight line. What the distance function does is to multiply or scale the speed per time unit by the number of time units, as in the running rabbit example.

Galileo’s Equations of Motions

Presumably, we assume that the final speed is bigger than the initial speed, \(v_1 > v_0\), because the ball has speeded up rolling down a slope (due to gravity). We call this “acceleration”. It is like a car speeding up when stepping on the pedal. The concept of acceleration had been discussed by earlier scholars, including Islamic physicist and mathematician Ibn Sina (Avicenna) in the 11th century, and European scientists like Jean Buridan and Nicole Oresme in the 14th century. However, Galileo was the first to develop a systematic approach to the study of acceleration and to formulate the laws of motion that describe the behavior of moving objects. He recognized that the motion of an object is determined not only by its speed, but also by its acceleration, which is the rate at which its speed changes over time. Galileo’s work on acceleration and his development of the laws of motion were groundbreaking and marked a significant departure from earlier understandings of motion, paving the way for the development of modern physics.

Following Galileo’s idea that acceleration is the rate at which its speed changes over time. We can define acceleration as how much speed has changed per unit time. Mathematically, we have,

The numerator is the difference between the final and initial speeds, i.e., the change in speed. Acceleration is the rate of change of speed per unit time. Therefore, the denominator is time.

Suppose another rabbit has an initial speed of 1 m/s, then 10 seconds later, the rabbit speeds up to 11 m/s. The acceleration of the rabbit during this period of time is computed as follows.

Rearranging the terms of \(\text{eq 2}\) above, we can write the final speed as

Or simply,

What this speed equation tells us is that if we know the object’s initial speed, the acceleration, we can predict or compute the object’s new speed after a time \(t\), and hence its distance (position). More impressively, this speed equation applies to any object in this universe!

To code it up, we have,

// the speed function
fun velocity(v0 : Double, acceleration : Double, time : Double) : Double {
    // v0 initial speed
    val v1 = v0 + acceleration * time;
    return v1
}

Suppose we fix the initial speed, \(v_0 = 0\), and the acceleration, \(1{\text{ m/s}}^{2}\), then the only changing quantity or variable is time. We also note that the speed equation is a linear function in time \(t\). In other words, given a time \(t\), the equation multiples \(t\) by \(a\). That is, the speed increases by \(a\) after each unit time, e.g., a second, is passed. Then, the equation adds the initial speed \(v_0\) as an offset to compute the new speed.

// the speed function with constant acceleration
// v0 = 0 m/s; a = 1 m/s^2
fun velocity1(time : Double) : Double {
    val v1 = velocity(0.0, 1.0, time);
    return v1;
}

Alternatively, the new speed after time \(t\) is starting with the initial speed \(v_0\), for each unit time passed, the equation adds an extra \(a\) to the speed until it does it \(t\) times.

\(v_0\), initially.

\(v_0 + a\), after 1 unit of time has passed

\(v_0 + a + a\), after 2 units of time has passed

\(v_0 + a + a + a\), after 3 units of time has passed

\(v_0 + a + … + a = v_0 + a*t = v_1\), after \(t\) units of time has passed

For example, let the initial speed be \(v = 1\text{ m/s}\) and acceleration \(a = 1{\text{ m/s}}^{2}\), then after 1 second, the new speed is

Coding up this process, we can draw the speed curve.

// plot the speed function with constant acceleration
val t = (0..20)

Plotly.plot {
    scatter {
        x.set(t)
        y.set(t.map { distance1(it.toDouble()) })
    }
}

Using this function or the curve, we know the speed of the rabbit at any point in time. We can therefore calculate its position (or distance from the initial position). However, we cannot apply the distance equation yet because the distance equation takes a constant speed, not a variable speed curve. To get around this problem, we instead use the average speed of the entire trip to plug into the distance equation. The average point of a straight line segment is simply the middle point of the line. Therefore, we have

To compute the distance of the accelerating rabbit at any time point, we plug in his average speed into the distance equation.

The code is:

// average velocity over time
fun velocity_average1(v0 : Double, time : Double) : Double {
    val v1 = velocity1(time);
    val avg = velocity_average(v0, v1);
    return avg;
}

// the distance function for a constant acceleration
fun distance2(time : Double): Double {
    val v = velocity_average1(0.0, time) // a linear function
    val d = distance(v, time);  // a linear function of linear function, combining the two together
    return d;
}

We can plot the distance curve of this accelerating rabbit.

// plot the distance function with a constant acceleration
val t = (0..20)

Plotly.plot {
    scatter {
        x.set(t)
        y.set(t.map { distance2(it.toDouble()) })
    }
}

We notice that the distance curve is no longer a straight line. It is indeed a curve, curving upward! We say this line has curvature. (A straight line has 0 curvature.) We call this a convex curve because it is curving upward. One most important feature of this distance curve is that it first increases slowly but then it speeds up and later on increases rapidly.

We can plot the two distance curves of both the constant-speed rabbit and the accelerating rabbit on the same plot to do a comparison.

// plot two curves on the same plot
val t = (0..20)

val trace0 = Scatter {
        x.set(t)
        y.set(t.map { distance1(it.toDouble()) })
        name = "constant speed"
}


val trace1 = Scatter {
        x.set(t)
        y.set(t.map { distance2(it.toDouble()) })
        name = "constant acceleration"
}

// Create plot with both traces
Plotly.plot {
    traces(trace0, trace1)
}

At first, the accelerating rabbit (orange) was lagging behind the constant-speed rabbit (blue). Later, the accelerating rabbit catches up and runs so much faster and further than the other rabbit. When the accelerating rabbit finishes the 200-meter race at time = 20 seconds, the constant-speed rabbit is only at the 100-meter mark, significantly lagging behind.

Acceleration is important! We note that before time = 10 seconds, the accelerating rabbit is lagging behind. We can zoom in this part of the curve and see/visualize better.

// find where the two curves meet
val t = (0..10)

val trace0 = Scatter {
        x.set(t)
        y.set(t.map { distance1(it.toDouble()) })
        name = "constant speed"
}


val trace1 = Scatter {
        x.set(t)
        y.set(t.map { distance2(it.toDouble()) })
        name = "constant acceleration"
}

// Create plot with both traces
Plotly.plot {
    traces(trace0, trace1)
}