Science and Engineering
What's the point of science? What's science? Here, I'm going to define science vs engineering: as being about "predicting an existing thing" vs "making a new thing that does what I want."
| Science | Engineering |
|---|---|
| Make models | Make things |
| Predict what's going to happen | Make something that does what I want |
| "Given this system exists, and right now it looks like so, if I push it here, what will it look like in one minute?" | "How do a build a system that will look like A until it's pushed, at which point it will switch to looking like B within one minute?" |
| What are the fundamental parts this system is composed of? | Given these basic parts, what can I build with them? |
Hopefully I can use both of these perspectives to lead to an understanding of LTI systems.
What's Prediction?
To predict something, as a scientist, you need to be able to measure it. We're also (at least for the purposes of this page) concerned with predicting something continuous (like a position, speed, or rotation) and not something discrete (like "will they get married" or "will it break"). So, to predict is to take some measurement of something, and then say that if you make that same measurement again some number of seconds in the future, it will have some specific value.
The time interval doesn't have to be measured in seconds, of course - it could be some number of minutes, days, femtoseconds, etc. I'll stick to seconds for this page to make it easier to talk and think about.
A good example of a measurement/prediction we might care about is "the angle of the moon in the sky." You can always give the angle of the moon in the sky as a number (measured in degrees). An example of making a prediction is: measuring the angle of the moon in the sky to be 30 degrees, then saying that in 20 days, the angle of the moon in the sky will be 50 degrees. Here, the prediction is "in 20 days, the angle of the moon in the sky will be 50 degrees."
Scientists like to do more than just make single predictions- they make laws. A scientific law is a sort of super-prediction - a prediction about what some measurement will be at all future times. Or, equivalently, if you know what a measurement is now, and you know the scientific law governing that measurement, if someone says "what will the result of that measurement be in n seconds?" you can give them an answer no matter what n is. Or, equivalently, a law is:
We can write this in more compact math notation as measurement(now + interval) = law(interval, measurement(now)) where measurement(t: seconds)
is the value of the measurement we care about at time t, interval is some number of seconds, now is the current time
(measured relative to some arbitrary starting point - you could easily let now be 0 and get the cleaner-looking measurement(interval) = law(interval, measurement(0)) )
and law is a function - any function! - with the signature
law(interval: Seconds, initial_measurement: MeasurementUnit) -> MeasurementUnit
Measuring Fake Stuff
With our knowledge of what a scientific law is, let's move on to a new, less lunar example. Let's say you have a pendulum, a weight tied to the end of a string. You and a friend were playing around with it, and you've come up with laws to describe the speed and mass of the weight:
velocity_law(interval: Seconds, initial_measurement: meters per second) -> meters per secondmass_law(interval: Seconds, initial_measurement: kilograms) -> kilograms
Don't worry about the details of these laws for now - just know you have them. If you know the pendulum's velocity right now, you can figure out what it'll be later, and same for mass.
Now, you've discovered/invented a new property of this pendulum that interests you - hurtyness (aka momentum). Hurtyness
is how much the pendulum hurts when it hits your hand. After years of careful study of hurtyness, you find the groundbreaking
result that hurtyness = velocity * mass. Eureka! And even better, since you can always figure out the pendulum's
hurtyness by multiplying together two measurements you have laws about, you have a law for hurtyness:
hurtyness_law(interval: Seconds, initial_measurement: kilogram meters per second) {
return velocity_law(interval, initial_velocity) * mass_law(interval, initial_mass);
}
Wait, something's wrong. That doesn't compile - we never defined initial_velocity or initial_mass. In fact, we never
knew them- we only have the initial hurtyness, and we can't get both velocity and mass from hurtyness. It seems like
despite having laws for finding future velocity from present velocity, and future mass from present mass, and a time-independent (i.e. always true)
law for finding hurtyness from velocity and mass, we still don't have a law for finding future hurtyness from present hurtyness.
If we wanted to get a hurtyness law from the velocity and mass laws, we'd need to place some restrictions on the
velocity and mass laws. Specifically, we want it so that when you expand out velocity_law(interval, initial_velocity) * mass_law(interval, initial_mass),
there's never an initial_velocity or initial_mass term on its own: each only appears as part of some initial_velocity * initial_mass term.
After all, to make our hurtyness law, we need to be able to use the law when we only know initial hurtyness, which is initial_velocity * initial_mass.
The only way to make sure that there are no lone initial_velocity or initial_mass terms is to require that
velocity_law(interval, initial_velocity) = some_function(interval) * initial_velocity, and mass_law(interval, initial_mass) = some_other_function(interval) * initial_mass.
Proving that this is the only thing that works is left as an exercize to the reader, but we can show it certainly does work:
hurtyness_law(interval, initial_measurement) = velocity_law(interval, initial_velocity) * mass_law(interval, initial_mass)
= some_function(interval) * initial_velocity * some_other_function(interval) * initial_mass
= some_function(interval) * some_other_function(interval) * initial_velocity * initial_mass
= some_function(interval) * some_other_function(interval) * initial_hurtyness
And we can even simplify this down to
hurtyness_law(interval, initial_measurement) = some_third_function(interval) * initial_hurtyness
Hey look! Not only did we get a law for hurtyness, that law even follows the same pattern we required for velocity and mass.
This means we can keep composing new properties out of ones we have patterned-laws for, and they'll have patterned-laws too.
Like if we made up a new property, heavy hurtyness, where heavy_hurtyness = hurtyness * mass, we could immediately know
the law for it as well.
This is known as "linearity." Since this pattern is so important, let's be clear about what it is: a linear law for a measurement is one that looks like
measurement(now + interval) = linear_law(interval) * measurement(now)
Something interesting is that while the value of measurement(time) will have some specific units - kilograms, meters per second, etc. -
the value of linear_law(interval) is unitless - it has no inherent physical meaning. Another example of
something that's unitless in this way is if I say I have "10 times as many apples as you do" - that 10 has no units. However, if I instead said
I had "90 more apples than you do", that 90 does have units: it's 90 apples.
The Part With Heavy Math
Okay, linear laws have a lot of cool properties, but that's a pretty specific pattern we're now forced into when writing science laws. What kind of things can we describe with just linear laws? That is, if we assume that there exists a True, Correct linear law that describes some measurement, what are we assuming about how that measurement changes over time? This is a complicated question. Let's ask a simpler one first: assuming the measurement looks ___________ over time, is there a linear law describing it?
First, let's try the simplest kind of measurement: constant. Astute readers may have wondered why we bothered making
a whole law for the pendulum's mass in the previous section, since normally that kind of thing doesn't change. good point!
However, we still want our laws to be able to describe constants. A constant measurement is one where measurement(time) = constant, where
constant is just some number (i.e. it doesn't change over time). Is there a linear law?
measurement(now + interval) ?=? linear_law(interval) * measurement(now)
constant ?=? linear_law(interval) * constant
linear_law(interval) = 1
Here, we can just let linear_law(interval) = 1, and tah-dah! the equation is satisfied. Constant measurements can be described with linear laws.
Okay, what about linear measurements? Like if you drive a car in a straight line with cruise control on,
the distance it's travelled is given by position(time) = constant * time. Since it's a linear measurement, it should have a linear law, right?
measurement(now + interval) ?=? linear_law(interval) * measurement(now)
constant * (time + interval) ?=? linear_law(interval) * constant * time
constant * time + constant * interval ?=? linear_law(interval) * constant * time
1 + (constant * interval) / (constant * time) ?=? linear_law(interval)
linear_law(interval) ?=? 1 + interval/time
We got a linear law that's a function of time as well as interval, which we said it can't be (remember, we want laws that are always true and always the same, no matter . So... I guess linear laws can't describe linear measurements. That's confusing. Also, this is a pretty basic type of measurement to fail. What are linear laws even good for?
linear_law(interval) = measurement(now + interval) / measurement(now)
Let's think about the linear law equation. On what type of graph is scrolling left/right the same as scaling the values?
The answer is exponentials! let's have measurement(time) = e^(constant * time):
measurement(now + interval) ?=? linear_law(interval) * measurement(now)
e^(constant * (now + interval)) ?=? linear_law(interval) * e^(constant * now)
e^(constant * now + constant * interval) ?=? linear_law(interval) * e^(constant * now)
e^(constant * now) * e^(constant * interval) ?=? linear_law(interval) * e^(constant * now)
e^(constant * interval) ?=? linear_law(interval)
linear_law(interval) = e^(constant * interval)
Yay! it worked!