How do distant clocks agree on a time?

Assigned remote time (stated procedure)

10 s

Round-trip speed

1 ls/s

Criterion check (declared clock B)

synchronized by definition

Section 2 rod chase: outbound / return legs

10 s / 10 s

Desynchronization of the moving pair (platform frame)

6 s

One-way light speed

not applicable (The model defines the one-way light speed by convention (Einstein's synchronization procedure), rather than measuring it independently.)

Three-station transitivity (A, B, C, mutually at rest)

transitive

Worked example: the light-signal rule sets the clock at B, 10 ls from A, to 10 s; the pair moving at 0.6c, 10 ls apart, has clocks that read 6 s apart, judged from the platform.

// desynchronizationObserved
const signed = kinematicDesynchronization(properSeparationLs, beta, 1 /* c, ls/s */);
const verdict = beta === 0 ? "they-agree" : beta > 0 ? "trailing-clock-ahead" : "leading-clock-ahead";

// synchronizationRound (Einstein's midpoint rule)
const assignedRemoteTime = (emissionTimeA + receptionTimeA) / 2;
const roundTripSpeedLsPerS = (2 * separationLs) / (receptionTimeA - emissionTimeA);

To give a time to something that happens far away, send a light signal there, let it bounce back, and take the moment halfway between sending and return. Two clocks set this way while riding together do not agree when they are judged from a platform they pass.

Section 1 starts from the fact that every statement of time is a statement about simultaneous events: the train arrives, and the small hand of my watch points to 7. A clock at A times the events near A, and a like clock at B times the events near B, but nothing yet gives A and B a common time. Einstein supplies one by definition: the time light takes from A to B is set equal to the time it takes from B back to A. A ray leaves A at A-time t_A, is reflected at B at B-time t_B, and returns at A-time t′_A; the clocks run synchronously when t_B − t_A = t′_A − t_B. He then fixes, in agreement with experience, that 2AB/(t′_A − t_A) = V, the speed of light in empty space, is a universal constant. In the lab a flash sent at 0 s and returned at 10 s gives the reflection the time 5 s; the one-way speed is never measured, and the lab reports it as not applicable. Section 2 applies the same test to clocks at the ends of a rod of length r_AB that moves at v, with the clocks set in the resting system. Riders find t_B − t_A = r_AB/(V − v) and t′_A − t_B = r_AB/(V + v), 25 s and 6.25 s for 10 light-seconds at 0.6V, so they judge the clocks out of step. By the transformation of section 3, a pair set in step by its own riders a distance L apart reads out of step on the platform by vL/V²: 6 s for L = 10 light-seconds at 0.6V, with the trailing clock ahead.

Why a definition is needed: to measure how long light takes from A to B you must read the departure on A's clock and the arrival on B's, and that already assumes the two clocks agree, which is the thing to be settled. So section 1 does not measure the one-way time; it stipulates that the two legs take equally long. The rule gives B's clock the reading at reflection t_B = t_A + (t′_A − t_A)/2, halfway between sending and return on A's clock. With stations 5 light-seconds apart, a flash sent at 0 s is back at 10 s, so the reflection is assigned 5 s; a second flash sent at 20 s is back at 30 s and is assigned 25 s, which is consistent with the first. The round trip needs only A's clock, so it is a real measurement: with stations 10 light-seconds apart the flash is back after 20 s, and 2 × 10/20 = 1 light-second per second, the speed V. Einstein also assumes, without proof, that the rule is symmetric (if B is in step with A, then A is in step with B) and transitive (two clocks in step with a third are in step with each other). Section 2 moves the rod. Its clocks are set in the resting system, and riders test them with the same rule. Going out, the light must catch the far end, which recedes at v: after a time T the light has gone VT and the end has reached r_AB + vT, so T = r_AB/(V − v) = 10/(1 − 0.6) = 25 s. Coming back, the near end runs to meet the light: T = r_AB/(V + v) = 10/1.6 = 6.25 s. The legs are unequal, so by the riders' own test the clocks are not in step. For a pair set in step by its riders, section 3's transformation τ = β(t − vx/V²), with β = 1/√(1 − v²/V²), gives the answer on the platform. At one platform time t, the two clocks stand L/β apart, so their readings differ by β × v × (L/β)/V² = vL/V². For L = 10 light-seconds and v = 0.6V that is 0.6 × 10 = 6 s. The clock at smaller x, the trailing one, reads more, and at v = 0 the offset vanishes.

export function synchronizationRound(
  input: SynchronizationRoundInput,
): KinematicResult<SynchronizationRoundResult> {
  const { emissionTimeA, receptionTimeA, separationLs } = input;
  if (!finite(emissionTimeA, receptionTimeA)) {
    return outsideDomain("nonfinite-input", "Emission and reception times must be finite.");
  }
  if (receptionTimeA <= emissionTimeA) {
    return outsideDomain(
      "invalid-round-trip",
      "A round trip's reception must occur strictly after its emission.",
    );
  }
  const badSeparation = refuseSeparation(separationLs);
  if (badSeparation) return badSeparation;

  const assignedRemoteTime = (emissionTimeA + receptionTimeA) / 2;
  const roundTripSpeedLsPerS = (2 * separationLs) / (receptionTimeA - emissionTimeA);
  const criterionOffset =
    assignedRemoteTime - emissionTimeA - (receptionTimeA - assignedRemoteTime);
  return ok({
    assignedRemoteTime,
    roundTripSpeedLsPerS,
    equalsC: Math.abs(roundTripSpeedLsPerS - C) <= 1e-9,
    criterionOffset,
  });
}

export function movingRodLegs(input: MovingRodLegsInput): KinematicResult<MovingRodLegsResult> {
  const { separationLs, beta } = input;
  const badSeparation = refuseSeparation(separationLs);
  if (badSeparation) return badSeparation;
  const bad = refuseSuperluminal(beta);
  if (bad) return bad;
  const outboundLegS = separationLs / (C - beta);
  const returnLegS = separationLs / (C + beta);
  return ok({
    outboundLegS,
    returnLegS,
    criterionSatisfiedInStationaryFrame: beta === 0,
  });
}

export function desynchronizationObserved(
  input: DesynchronizationInput,
): KinematicResult<DesynchronizationResult> {
  const { properSeparationLs, beta } = input;
  const badSeparation = refuseSeparation(properSeparationLs);
  if (badSeparation) return badSeparation;
  const bad = refuseSuperluminal(beta);
  if (bad) return bad;
  const signed = kinematicDesynchronization(properSeparationLs, beta, C);
  if (signed.status !== "value") return signed;
  const verdict: DesynchronizationVerdict =
    beta === 0 ? "they-agree" : beta > 0 ? "trailing-clock-ahead" : "leading-clock-ahead";
  return ok({ desyncMagnitudeS: Math.abs(signed.value), verdict });
}

The two one-way transit times of the synchronizing signal are set equal by definition, not measured: Einstein's stated procedure (paper 3, section 1). Alternative: slow clock transport. Requires a dynamical assumption about how a clock's rate depends on its motion, not merely a convention about signals. In the limit of vanishingly slow transport, within one inertial frame, it agrees with the light convention; at any finite transport speed the two differ by an amount that goes to zero with the transport speed. This is a limiting statement, never an exact equivalence at finite speed.