Special relativity · The central construction

Build the map, don't receive it.

What map between two inertial frames keeps both postulates, and what does each requirement decide?

Construct the map

Construct the Lorentz map

Static worked example

Model note
  • Galilean composed velocity (slow case) (slowCaseGalilean), Galilean speed of the rightward ray, as a fraction of c (rightRayFraction) and Galilean speed of the leftward ray, as a fraction of c (leftRayFraction): Host calculation, by the site's own reference code. Computed in kinematics.galileanVelocity.
  • Lorentz factor (lorentzFactor): Host calculation, by the site's own reference code. Computed in kinematics.gamma.
  • Rapidity (rapidity): Host calculation, by the site's own reference code. Computed in kinematics.rapidity.
  • Computed from the settings last applied (settings revision 1, result 1).
  • Not modeled: non-aligned axes and rotations; accelerated frames; gravity; a fully rigorous derivation of linearity; origins that do not coincide; non-collinear composition (the velocity-composition laboratory).

What map between two inertial frames keeps both postulates, and what does each requirement decide?

Frame speed and slow case
Experiment settings the slow-case observer and object speeds

Changes here apply with Apply settings.

Enabled constraints (the engine solves only what you enable)
Test a hand-built candidate (never a change to the world)
Later aids

Construction result

The ordinary change of frame (a = b = 1, d = 0): slow objects pass, and light fails, at c − v one way and c + v the other.
RequirementHow far it misses (0 means it holds)
Right-moving light stays at c−1.799 × 108 m/s
Left-moving light stays at c−1.799 × 108 m/s
Reciprocity: the map back to K is the same map at −v−0.3600
Isotropy: a(v) = a(−v)0.000
Identity branch: at v = 0 the map changes nothing0.000
A light ray across the motion stays at c0.000

The Galilean shelf step

Slow case (observer 30 m/s, object 10 m/s): the ordinary change of frame gives −20 m/s, and the exact map differs from that by 6.68 × 10−14 m/s. Light rays at v = 0.6c: right-moving 0.4c, left-moving −1.6c.

The slow case needs a slow observer: this is why the observer speed above is entered separately from the frame speed v used for the light-ray test.

Not modeled: non-aligned axes and rotations; accelerated frames; gravity; a fully rigorous derivation of linearity; origins that do not coincide; non-collinear composition (the velocity-composition laboratory).

Show the code

The site’s own reference code for this law, in TypeScript. It computes the numbers above when the page runs it, and it is what the page uses wherever a FrankenSim result is not available.

galileanVelocity · src/physics/reference/kinematics.ts · this site’s source, as built · sha256:61ffd6f21cfa123929d7aaedeee5caa696acfe8d845de83c38b7d5ff94eaced7

This function computes the listed outputs when it runs.

In words

Subtract the frame's speed from the speed measured in the resting system. That is the everyday rule this laboratory is testing, and it carries no reference to the speed of light at all.

Implementation

export function galileanVelocity(u: number, v: number): KinematicResult<number> {
  if (![u, v].every(finite))
    return outsideDomain("nonfinite-input", "Galilean velocity needs finite u and v.");
  return ok(u - v);
}

The site’s own reference code for this law, in TypeScript. It computes the numbers above when the page runs it, and it is what the page uses wherever a FrankenSim result is not available.

rapidity · src/physics/reference/kinematics.ts · this site’s source, as built · sha256:e65b9b89f2c7b54cbfbb9631ea63c2f3eb3c11f9408a9b93bea81701f5bee1e6

This function computes the listed outputs when it runs.

In words

Rapidity is the inverse hyperbolic tangent of v/c, computed here as half the logarithm of (1 + beta) over (1 - beta). Two collinear boosts have rapidities that simply add, which is what makes it useful: the speeds compose by the addition theorem instead, and never add. The factor and the speed follow from it, since gamma is the hyperbolic cosine of the rapidity and gamma times beta its hyperbolic sine.

Implementation

/**
 * artanh(beta). Identifier rapidity; glyph RAPIDITY_GLYPH from the concordance.
 * artanh(0.6) = ln 2. Later aid: gamma = cosh(rapidity), gamma*beta = sinh(rapidity).
 */
export function rapidity(beta: number): KinematicResult<number> {
  if (isMode1904()) refuseModernSurface("rapidity");
  const bad = refuseBeta(beta);
  if (bad) return bad;
  return ok(0.5 * Math.log((1 + beta) / (1 - beta)));
}

The site’s own reference code for this law, in TypeScript. It computes the numbers above when the page runs it, and it is what the page uses wherever a FrankenSim result is not available.

galileanRelativisticVelocityDifference · src/physics/reference/kinematics.ts · this site’s source, as built · sha256:55c9c824481d821897c873699fbed848645ee9ecf60ca46dd0e47c8255ee5932

This function computes the listed outputs when it runs.

In words

The relativistic transformed velocity is (u - v) divided by (1 - u v / c squared); the Galilean one is (u - v). Their difference is the first times the small factor relativeSize, which is (u v / c squared) divided by (1 - u v / c squared). At everyday speeds that factor is around ten to the minus seventeen, so the difference is far below anything the two velocities could be measured to.

Implementation

/**
 * Relativistic minus Galilean transformed velocity, cancellation-free:
 * (u - v) * (u v / c^2) / (1 - u v / c^2).
 */
export function galileanRelativisticVelocityDifference(
  u: number,
  v: number,
  c = speedOfLightMetresPerSecond(),
): KinematicResult<Readonly<{ difference: number; relativeSize: number }>> {
  if (![u, v, c].every(finite) || c <= 0) {
    return outsideDomain("nonfinite-input", "Difference needs finite speeds and positive c.");
  }
  if (Math.abs(u) > c || Math.abs(v) >= c) {
    return outsideDomain(
      "superluminal-observer",
      "Difference needs subluminal frame speed and |u| <= c.",
    );
  }
  const relativeSize = (u * v) / (c * c) / (1 - (u * v) / (c * c));
  return ok({
    difference: (u - v) * relativeSize,
    relativeSize,
  });
}
The same construction without dragging, color, or a canvas

Every action here is a checkbox toggle or typed text entry, and every result is a text table or sentence. Enable constraints from the checklist, type a hand-built candidate's coefficients, and read the residual or the fixed map. No control depends on dragging a handle, distinguishing color alone, or reading a canvas.

Here you build, one requirement at a time, the rule that turns one observer's positions and times into another's. Ask that light have the same speed for both observers and that neither observer be special, and only one rule is left: the one Einstein found in 1905.

The candidate maps have the form x′ = a(x − vt) and t′ = bt + dx, with a separate scale across the motion, and the engine solves only the requirements you tick. With none ticked it tests the ordinary change of frame, a = b = 1 and d = 0: a slow object's speeds subtract as mechanics expects, but at v = 0.6c a ray of light comes out at 0.4c going one way and 1.6c going the other. Requiring light at c in both directions forces b = a and d = −av/c2, and leaves a free. Reciprocity, that the map from k back to K is the same kind of map with −v, gives a(v)a(−v)(1 − v2/c2) = 1. Isotropy, that space has no preferred direction, gives a(v) = a(−v). Together they leave a = ±1/√(1 − v2/c2), and the branch that does nothing at v = 0 takes the positive root, 1.25 at 0.6c. A ray crossing at right angles then fixes the scale across the motion at 1. Section 3 of the paper reaches the same map by another path. It synchronizes k's clocks by the rule of Section 1, solves the resulting equation for the time τ of k, and is left with an unknown factor φ(v). Einstein then shows φ(v)φ(−v) = 1 and, by symmetry, φ(v) = φ(−v), so φ(v) = 1. Those two steps are this instrument's reciprocity and isotropy.

Modern qualifications

Einstein wrote V for the speed of light and ξ, η, ζ, τ for k's coordinates, and he set x′ = x − vt as a Galilean auxiliary, not the moving coordinate. His Section 3 begins from clocks, not from light speeds in two directions: light leaves k's origin at τ0, is reflected at x′ at τ1 and returns at τ2, and the rule of Section 1 requires ½(τ0 + τ2) = τ1. For small x′ this gives ∂τ/∂x′ + v/(V2 − v2) ∂τ/∂t = 0, and with linearity, which he takes from the homogeneity of space and time, τ = φ(v)β(t − vx/V2), where β is the factor now written γ. He fixes φ(v) with a third system moving at −v and a rod set across the motion, whose length in K cannot depend on the direction of travel. Lorentz had published equivalent coordinate equations in 1904, as a change of variables with a local time, and Poincaré named them the Lorentz transformation in June 1905 and showed they form a group; the paper cites neither. The matrix, its eigenvalues 2 and 0.5 on the light lines at 0.6c, and the rapidity ln 2 = 0.693 are later aids: the matrix picture is Minkowski's of 1908, and the word rapidity is Robb's of 1911.

Open the derivation

The Galilean shelf step

The ordinary change of frame, x′ = x − vt, works for slow objects: two speeds slower than light compose the way ordinary mechanics expects, and the deviation from the relativistic result is unmeasurably small. It fails completely for light: a ray moving at c in one frame is measured at c − v or c + v in the other, not c. That conflict, not an assumed interval, is where the construction starts.

No answer preinstalled

The engine above solves only the constraints you enable. The Lorentz factor never appears until the branch step fixes it; the Minkowski interval never appears at all in the construction, because interval preservation is a modern verification oracle, not a 1905 premise. Requiring it up front would make the derivation circular.

Embed this laboratory on another page. It starts from its worked defaults, not your current settings.