wrog: (rockets)
[personal profile] wrog

My Special Relativity series continued from part 4.

Today's topic is how to translate Moving People coordinates to Stationary People coordinates or to other Moving People and how it's really like a rotation except where it isn't, and how there's this thing that's like a rotation angle but different.

A Surveying Problem

So I needed a survey of my backyard to find out where everything is. The ISO (Stationary) People who I was originally going to hire were busy that day and also expensive, so I had the Rotated (Stationary) People do it, instead.

I now have coordinates for everything, starting with that Cherry Tree at (00) in the middle of the yard that everybody likes and so everybody puts it in the center of their coordinates

(and yes, we're writing coordinates vertically today, and yes, we're not doing anything with altitude and time here, so it's just 2 dimensions),

including, e.g., the Birch Tree, which happens to be at (54)rot, meaning it's 5 µsec to the east and 4 µsec to the north

(and yes, the µsec = 1 microsecond ≈ 1000 feet, will be our distance/time unit for today, and yes, my backyard is quite large)…

…and that 'rot' annotation is there to say this is in Rotated People coordinates, though we can be more explicit and write it this way:

[rotated_East]*5+[rotated_North]*4

where [rotated_East] and [rotated_North] are 1-µsec arrows in the directions the Rotated People want them to be. (and yes, we are assuming a particular notion of how to add arrows and multiply them by numbers that I hope doesn't have to be explained),

except I like to group the basis arrows and the coordinates like this:

( [rotated_East][rotated_North)×(54)

Here, × is matrix multiplication.

(in case you don't know about matrices, they are arrays of numbers — or other things that can be added and multiplied — arranged in rows and columns, and this shows how to multiply a single row (1×n) matrix by a single column (n×1) matrix, i.e., you pair everything off (number of columns on the left has to equal the number of rows on the right for this to be doable), multiply each pair, and then add those products together.

Later on, we'll see examples with multiple rows on the left, in which case the result will have that many rows; and/or multiple columns on the right, in which case the result will have that many columns; and then we're doing all possible combinations of multiplying a row on the left by a column on the right; this should make more sense once you see it happening)

At the end of the day, we have this self-contained description of how to get from the Cherry Tree to the Birch Tree.

The only problem is we actually wanted something different, namely coordinates in terms of the internationally standard [true_East] and [true_North], what the ISO People would have given us.

…and we're currently screwed because we do not yet have any idea which way [rotated_East] goes.

Solution:  Bring back the Rotated People and point out the final clause in their contract that requires them to pound a stake in the ground 1 µsec (their) east of the Cherry Tree. That done, I can now bring in the ISO People to measure it and give me authoritative coordinates for just that one position (which will be way cheaper than having them re-do the entire survey).

And so we get that [rotated_East] is (cs)ISO for some numbers c and s — reasons for my choice of letters here will remain mysterious for the time being. Restating this yet more verbosely:

[rotated_East]=( [true_East][true_North)×(cs)

Are we still screwed because we didn't make them drive a [rotated_North] stake as well?

As it happens, no. Because everybody is this contrived legal framework has to use the same distance unit in all directions and have North be perpendicular to and counterclockwise from East, which is enough to infer what we need from what we know about rotations
(or, if you prefer, what we want to be true about rotations that then dictate what the coordinate transformation for a rotation has to be, and then we'd go back and prove everything we wanted to be true, except we're totally lazy so we'll instead have you do that part as an exercise).

Here is what the ISO People and all of the Rotated Peoples have to agree on:

  • distances between trees, etc.,
  • lines, i.e. if 3 or more trees are in a line, everyone has to see them that way,
  • perpendicularness, i.e. if two lines have negative inverse slopes (v, 1/v), everyone has to see them that way,
  • parity, i.e., everyone has to agree on what "counterclockwise" means
    (or, rather, if we are going to allow for there being Reflected Left-handed Peoples, we'll just flip the signs on all of their north-south measurements, work out how the coordinate translation works for the corresponding Right-Handed People, and then flip back, so we're not actually losing anything by ignoring all Left-Handed People here).

Agreeing on perpendicularness means [rotated_North] has to be some multiple of (sc)ISO,
Agreeing on distances means we have to have c2+s2=1 and so that multiple for [rotated_North] has to be ±1,
and agreeing on parity rules out it being −1.

So, starting with our previous expression for the location of the Birch Tree

( [rotated_East][rotated_North)×(54)

we can substitute

=(( [true_East][true_North)×(cs)  ,  ( [true_East][true_North)×(sc))× (54)

and once you see how matrix multiplication works when there are multiple columns on the right, you'll see that we have

=(( [true_East][true_North)× (cssc))× (54)

Then we do the sneaky thing:

=( [true_East][true_North)× ((cssc)× (54))

this being something that is generally true of matrix multiplication (it's associative!), the proof of this being a wall of algebra, but essentially it's that the whole expression is a sum of things we can do in any order we want (but you should write both versions out in full if you don't believe me)

Next, we show how matrix multiplication works when you have multiple rows on the left:

=( [true_East][true_North)× (5c4s5s+4c)

and thus we see that the Birch Tree is at (5c4s5s+4c)ISO.

the point of this being that the 2×2 matrix (cssc) is everything you need for translating Rotated People coordinates for any point in my backyard to ISO. Recall that all we needed to get the matrix is to know how (10)rot, otherwise known as [rotated_East], translates.

But it turns out that, given all of the constraints we've put on our surveyors, there is an even easier and more useful way to describe [rotated_East].

Rotation Angles and the Unit Circle

Consider the set of all locations that are 1 µsec away from the Cherry Tree. These points form a magic curve known as a "circle", which has a number of fun properties that the ISO People and all Rotated Peoples must agree on:

  • whether any given place in my backyard is on it, inside it, or outside of it, because we all have to agree on distances;
    any rotation takes the circle to itself,
    [true_East] and all possible [rotated_East]s including (10), have to be on there somewhere,

  • that every point on the circle has a unique tangent line through it that never goes inside the circle, and that this line will also be perpendicular to the (radius) line from the center to that point.

    This is easy to see for the circle's easternmost point (10) and the north-south line going through there; all other points on that line are clearly farther away, but if you were to tilt the line even slightly it would cut into into the circle. And then we can rotate this scenario however we like to get to any other point on the circle that we care about, since rotations take lines to lines and preserve distances+perpendicularities,

    so for any [rotated_East], the tangent line at that point will be parallel to the corresponding [rotated_North] (remember this for later)

  • distances measured along the circle starting at [true_East] and proceeding counterclockwise,
    meaning for every [rotated_East] there is a unique corresponding distance 𝜃 from [true_East] somewhere in 0𝜃<2π, which we'll call the rotation angle (surprise).

And now we can rip off the bandages and express c and s as functions of 𝜃, using the names you'll have seen before if you've been anywhere near a trigonometry course.

[rotated_East] becomes (cos𝜃sin𝜃)ISO.

cos0=1 −1cos𝜃1 sin0=0 −1sin𝜃1 tan𝜃 sin𝜃cos𝜃 (= slope) −∞tan𝜃+∞ sec𝜃 1/cos𝜃 1|sec𝜃|+∞   cos(𝜃) = cos𝜃 (cos𝜃)2+(sin𝜃)2=1 sin(𝜃) = sin𝜃 1+(tan𝜃)2=(sec𝜃)2

These functions, cosine and sine are thus magic black boxes that tell you where all of the points of the unit circle are. They have all manner of wacky properties, some of which we can read straight off from what we already know about circles (see box).

They also get used to define other functions, the most important (IMHO) being the one you need to convert from angles to slopes and would, in a just universe, be called slope() but instead is called tan() for some reason (stands for "tangent"; and no, I don't know why. So many things in math are weird historical traditions).

The matrix for translating Rotated People coordinates to ISO coordinates is now

(cos𝜃sin𝜃sin𝜃cos𝜃)

Since the circle is a 1D curve where you can only go clockwise or counterclockwise, and all of the various Rotated People have to agree on distances along it, rotation angles have to add and subtract (modulo 2π) the way you'd expect.

And, it should make no difference whether you add first then convert to a matrix or convert to matrices first and matrix-multiply them, so we must have

(cos𝜃1sin𝜃1sin𝜃1cos𝜃1)×(cos𝜃2sin𝜃2sin𝜃2cos𝜃2)=(cos(𝜃1+𝜃2)sin(𝜃1+𝜃2)sin(𝜃1+𝜃2)cos(𝜃1+𝜃2))
How to add slopes:
cos(𝜃1+𝜃2)=cos𝜃1cos𝜃2sin𝜃1sin𝜃2 sin(𝜃1+𝜃2)=sin𝜃1cos𝜃2+cos𝜃1sin𝜃2 tan(𝜃1+𝜃2)=tan𝜃1+tan𝜃2 1tan𝜃1tan𝜃2 = slope1+slope21slope1slope2

which is enough to derive yet more properties that cos(), sin(), and friends have to satisfy and also give us a handy rule for adding slopes, in case you wanted to know how to do that (see box).

As a special case, we can see how adding an angle of 0 is the same as multiplying by ( 1 0 0 1), the identity matrix that takes coordinate pairs to themselves.

Finally, if it so happens that you want to go the other way, i.e., convert ISO coordinates back to Rotated coordinates, while inverting a matrix is normally somewhat complicated, here you can just rotate back, i.e., by 𝜃.

Next we see how to get something like this to work for the John Hancock Tower…

A Spacetime Surveying Problem

It seems the Moving People collected some huge mass of data on events they've observed that we the Stationary People neglected to measure ourselves and have suddenly discovered we care about. And now we want them all translated onto our spacetime grid.

What does this translation (sometimes called a velocity boost, or, because math things always have to be named after people, the Lorentz transformation) look like?

Really, it's roughly the same story as for converting from rotated coordinates in my backyard survey, modulo some odd, extra, annoying minus signs (or lack thereof).

Recall that there are two (yes, we are back to 1D space and 2D spacetime) unit arrows that define our Stationary People grid. Starting from some origin event — a Cherry Tree Explosion in the JHT lobby that everyone is sad about and so as a kind of memorial we all use (00) to refer to it — we have:

  • [true_Later] from the origin to 1 µsec in the future in the same place, and

  • [true_Up] from the origin to the simultanenous event 1 µsec upstairs.

The Moving People in their Moving John Hancock Tower whose lobby happens to coincide with ours for the Cherry Tree Explosion do likewise, their Cherry Tree Explosion person having events respectively 1 µsec (proper time) in his future (or lack thereof if he doesn't survive the explosion), denoted [moving_Later] and 1 µsec (proper distance) upstairs [moving_Up] along the Moving snapshot that includes the explosion.

Following the surveying discussion, it would seem that if this Moving Person at the origin event could, out of professional courtesy, arrange to set off a flash 1 µsec later (the spacetime equivalent of pounding a stake into the ground) that we could measure to get numbers for [moving_Later], that would suffice. We would then have

[moving_Later] = (cs)stat = ( [true_Later][true_Up)×(cs)

where, as you might guess, the time coordinate is on top and, thus, c and s are, respectively, how much later and farther up the flash is in Stationary People measurements.

Going down the list of what the Stationary People and all of the various Moving Peoples have to agree on:

  • the direction of time (because entropy, etc.),
    so c doesn't ever go negative,

  • lines,
    regardless of whether the line is somebody's floor history (STL), somebody's snapshot (FTL) or a light ray trajectory,
    i.e., if 3 or more events are in a line, then everybody sees them in a line of the same type

  • pairs of lines having inverse velocities,
    i.e, if the same Moving People can have one line as a snapshot and the other line as a floor history, this will not be something that differently Moving People can disagree about,

    so, with [moving_Later]'s velocity being s/c,
    [moving_Up]'s velocity needs to be c/s,
    and therefore [moving_Up] has to be some multiple of (sc)stat
  • intervals between events,
    so, since [moving_Later] is supposed to be 1 µsec in proper time, we need
    c2s2=1 … oops, this is different…
    from which we have (sc)stat is 1 µsec in proper distance,
    and therefore [moving_Up] has to be plus or minus that.

  • parity, i.e., which way is up
    (or, rather, if there are any Upside-Down Moving Peoples, we can just change the signs on all of their up-down measurements, work out how the translation works for the corresponding Rightside-Up Moving People, and then flip back, so we don't actually lose anything by ignoring them for now),
    which, since we're already requiring c to be positive, rules out the minus option,

and therefore, similarly to how rotations work, you translate Moving coordinates to Stationary coordinates by multiplying them on the left by the 2×2 matrix (cssc) and it sufficed to know how (10)mov otherwise known as [moving_Later], translates.

Velocity Angles and the Unit-Later Hyperbola

Emulating what we did for my backyard surveyors, we can try to describe all of the possible [moving_Later]s.

However, the set of all events (cs) that are 1 µsec in proper time into the future from (00) is very much not a circle.

Just to get clear what the shape is, in case you haven't seen it before (see box if you care about why it has to look like this):

c2s2=1 with c positive implies both c1 and c>|s| but does not constrain s in any way.

Dividing both sides by c+|s| (guaranteed positive) to get c|s|=1c+|s| and taking c1 into account means

|s| < c |s|+11+|s|

where that last term is generally quite small and will never be greater than 1,

so what we have is a curve that looks very much like and is confined to a very small futureward strip from c=|s|, the combined paths of two (up and down) light rays eminating forwards in time from (00), getting virtually indistinguishable from them as s goes to ±∞… and the only place it's really different is in the neighborhood of s=0, where we've sanded off the corner and where c reaches its minimum value (1) and furthest deviation from |s|

Anyway this is a hyperbola. Or, at least, half of one; the full shape includes a disjoint Unit Ago c−1 portion (that we are just going to ignore from now on).

Every possible STL velocity s/c is represented along there somewhere.

And, as with the ISO and various Rotated Peoples and the unit circle, the Stationary and various Moving Peoples have to agree on:

  • which events are on the hyperbola, before it, or after it, because we all have to agree on intervals and proper times, and so
    the boost takes the hyperbola to itself,
    [true_Later] will be on there somewhere,
    and likewise for all of the various [moving_Later]s, including (10).
  • that every point on the hyperbola has a unique tangent line that does not cross through it, which will also be inverse-slope to the line from (00) to that point.

    This is easy to see in the case of (10), the earliest (according to whoever's coordinates these are) event on the hyperbola, and the up-down snapshot line through there, where every other event on the snapshot is clearly before (nonzero space and 1 µsec of time means a proper time that is strictly smaller), but tilting the line even slightly makes it include at least one afterwards event and thus makes it cross through the hyperbola.

    And then we can use the boost matrix to shift this all to any other event on the hyperbola, recalling this takes lines to lines, preserves intervals, and preserves inverse-slopiness.

An important consequence is that, we have, at every event along the hyperbola, a tangent line, which is the line most closely matching what the hyperbola is doing at that point, with FTL velocity, meaning the hyperbola is "like a snapshot" everywhere, and thus it makes sense to talk about measurerments of proper distances along it no matter where we are.

This is an issue that did not come up in the surveying scenario, because in my backyard it's legal to measure distances in all directions, whereas in spacetime, as we've seen, some directions will be spacey and others will be timey, and we have to keep straight which is which.

And now we have to have universal agreement on

  • proper distances measured along the hyperbola starting at [true_Later] and proceeding upwards, and thus

    for every [moving_Later] there is a unique corresponding distance 𝜑 from [true_Later], which we'll call the velocity angle.

This is actually simpler than the case for rotation angles. The hyperbola does not "wrap", i.e., there are no worries about "going around it too many times" or "going around the wrong way" like you can with a circle, and hence none of this silliness where we have to pick a range and do everything modulo 2π.

Every possible STL velocity has a unique velocity angle and vice versa.

cosh0=1 1cosh𝜑 sinh0=0 −∞<sinh𝜑<+∞ tanh𝜑 sinh𝜑/cosh𝜑 (= velocity) −1<tanh𝜑<1 sech𝜑 1/cosh𝜑 0<sech𝜑1   cosh(𝜑)=cosh𝜑 (sinh𝜑)2+1=(cosh𝜑)2 sinh(𝜑)=sinh𝜑 (tanh𝜑)2+(sech𝜑)2=1

Here, too, we can express c and s as functions of 𝜑, though these names show up way less often.

[moving_Later] is now (cosh𝜑sinh𝜑)stat.

These hyperbolic cosine and hyperbolic sine functions ("cosh" and "sinch", if you need pronunciations), being the corresponding magic black boxes that tell us where every point on the hyperbola is, are, of course, completely different from their circular cousins, but they satisfy many similar looking properties that we can, again, read off from what we (now) know about hyperbolas (see box).

And likewise, we have a similar raft of other functions that traditionally get defined here, the most important (IMHO) being the one you need to convert from velocity angles to velocities, but, of course, has the completely incomprehensible name tanh() (for hyperbolic tangent or "tanch", I guess).

the matrix for translating Moving People coordinates to Stationary People coordinates is now

(cosh𝜑sinh𝜑sinh𝜑cosh𝜑)

Since velocity angles are proper distances, everyone has to agree on them. And, being distances along a 1D curve, they will, unlike velocities, have to add and subtract in the ways you'd expect.

How to add velocities:
cosh(𝜑1+𝜑2)=cosh𝜑1cosh𝜑2+sinh𝜑1sinh𝜑2 sinh(𝜑1+𝜑2)=sinh𝜑1cosh𝜑2+cosh𝜑1sinh𝜑2 tanh(𝜑1+𝜑2)=tanh𝜑1+tanh𝜑21+tanh𝜑1tanh𝜑2 =v1+v21+v1v2

Also, as with rotations, it doesn't matter whether you add first and then covert to a matrix or convert first and then do the matrix multiplication; you get the same result either way. Which, again, is enough to derive yet more properties that cosh(), sinh(), and friends have to satisfy, and we now (finally) get the handy rule for adding velocities (see box).

And, as with rotations, a velocity angle of zero corresponds to the identity matrix, and undoing a boost by 𝜑 is as simple as boosting by 𝜑.

Finally it's worth noticing that when velocities are really small, the unit-later hyperbola becomes indistinguishable from a vertical line, proper distances along it become indistinguishable from coordinate distances, and so velocity angles becomes indistinguishable from velocities. E.g., the difference between 10⁻⁷ lightspeed (roughly 67mph) and the corresponding velocity angle is around 3×10⁻²², so,…yeah. (Which is how Newton got the idea that velocities can be simply added, because at that scale they mostly can).

Velocity angles are unbounded?

Something we need to be at least slightly careful about is that proper distances, for measurements along a very-close-to-lightspeed snapshot (or proper times along a very-close-to-lightspeed trajectory, as we saw in the Twin Paradox diagram) can be very much smaller than they appear on the page (e.g, if Δz and Δt are both quite large, it's possible to forget we need to be subtracting their squares rather than adding them as we do for Euclidean geometry)…

… at which point it becomes legitimate to ask whether one can indeed have arbitrarily large proper distances along the unit-later hyperbola; this does not immediately follow from the hyperbola being infinite in the Euclidean sense (what we see on the page). There are, e.g., situations in hyperbolic geometry where things that have seemingly infinite extent turn out to have finite area, so it would be good to know none of that bullshit is happening here.

One way to verify this is to look at the velocity addition formula:  For any STL velocity v, there is a corresponding velocity angle, which we can then double, and then it is just a matter of checking

v<2v1+v2<1
𝜑v 10.76 20.964 30.995 41−0.00067 51−9.08×10⁻⁵ 61−1.23×10⁻⁵ 71−1.66×10⁻⁶ 81−2.25×10⁻⁷ 91−3.05×10⁻⁸

which is a Small Matter of algebra (exercise!). What this says is, for any STL velocity, doubling the corresponding velocity angle indeed gets us to a faster velocity that is still STL, and therefore we can keep doing that forever. Meaning there is indeed no bound on how high velocity angles can go, even though the corresponding velocity always stays below lightspeed.

Also, we have numbers (box).

(Next up, John Hancock Tower, Special Edition with Gravity …)

Page generated Feb. 12th, 2026 04:34 am
Powered by Dreamwidth Studios