Mass–Energy · System boundaries & empirical checks

System boundaries and the energy ledger.

When energy leaves a body as radiation, which system loses mass, and which does not? Drag a thermodynamic boundary around the components and inspect what energy crosses it.

System boundary energy ledger

System-boundary energy ledger with cited energy-source cards

Static worked example

Model note

Energy change inside the boundary (energyChange), Mass change inside the boundary (massChange), Energy carried by the radiation (radiationEnergyChange), Mass change of the radiation alone (radiationMassChange), Energy change of body and radiation together (systemEnergyChange) and Mass change of body and radiation together (systemMassChange): Host calculation, by the site's own reference code. Computed in massEnergy.boundaryLedger.
Invariant mass of the emitted light (invariantMass): Host calculation, by the site's own reference code. Computed in massEnergy.fourMomentum.
Computed from the settings last applied (settings revision 1, result 1).
Not modeled: gravitational weighing; wall stresses, or external work beyond declared inputs; nuclear and chemical mechanisms beyond cited energies; heat losses not declared; neutrino and solar-wind mass loss; the practical measurability of tiny mass changes; the 1905 argument's premises (inherited, not re-derived); non-inertial or accelerated frames.

JavaScript is off. This is a complete worked example calculated when the site was built, and its values and explanations remain available. The controls need JavaScript to respond.

Predict before the numbers

A sealed box holds a battery-powered lamp and a mirror. When the lamp lights up inside, does the box's total mass change?

Three relations the model could have It increases, because light has been added. It decreases, because the lamp sends out energy. It stays the same, because the energy is still inside.

The result appears when you choose, say you have one in mind, or skip.

Compare

Inside the boundary

The radiation

Try

Experiment settings seven cited energy sources, notation

A cited energy source

Notation

Worked example: Radium-226 alpha decay, with the boundary around the body alone: the radiation escapes, and the energy figure is 4.871 MeV.

Where the boundary is drawn

Inside the boundary: the body alone. The radiation escapes.

Energy and mass inside the boundary

Inside the boundary: The body alone
Energy change ΔE: −1 J
Mass change Δm: −1.1127 × 10⁻¹⁷ kg

Case study: Radium-226 alpha decay
Mass change: 0.0052292 u/decay (5.229 mg/mol)

Case study facts: Radium-226 alpha decay

Citation: NuDat 3.0 / Evaluated Nuclear Structure Data File (ENSDF), Brookhaven National Laboratory (226Ra Q-alpha = 4.871 MeV).

1. System before:: Radium-226 nucleus at rest
2. System after:: Radon-222 nucleus and alpha particle after heat emission
3. Matter crosses boundary:: No (Closed system: The radon-222 nucleus and the alpha particle both stay inside the boundary.)
4. Radiation disposition:: escapes (The decay energy leaves as heat.)
5. Reference frame:: Rest frame of parent nucleus
6. Energy figure:: 4.871 MeV (energy released per decay)

7. Closed but not isolated: Nothing material crosses this boundary, but the system is not isolated: energy still enters or leaves it.

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.

evaluateMe03 · src/physics/reference/massEnergy.ts · this site’s source, as built · sha256:3e9ea1af4a87d89addf26618479bebd064d67ef5ce0091952a426570743deb22

This function computes the listed outputs when it runs.

In words

Read the chosen boundary, what happens to the radiation, and the energies, then pass them to the boundary ledger, the modern four-momentum calculation and the energy-source cards, and gather their results in one snapshot. A missing or invalid energy falls back to the default: one unit emitted, none put in.

Implementation

/**
 * Main reference evaluator for ME-03.
 */
export function evaluateMe03(input: Me03Input = {}): Me03Snapshot {
  const boundary = input.boundary ?? "body-alone";
  const disposition = input.disposition ?? "escapes";
  const emittedEnergy =
    Number.isFinite(input.emittedEnergy) && (input.emittedEnergy ?? 1) > 0
      ? (input.emittedEnergy ?? 1)
      : 1;
  const inputEnergy =
    Number.isFinite(input.inputEnergy) && (input.inputEnergy ?? 0) >= 0
      ? (input.inputEnergy ?? 0)
      : 0;
  const cardId = input.cardId ?? "me-03-card-radium";
  const mode = input.mode ?? "1905";
  const pulseSystem = input.pulseSystem ?? "two-opposite";
  const set = getConstantSet(input.constantSetId ?? "modern-si-2019");
  const c = constantValue(set, "speedOfLight").value;

  const ledger = evaluateBoundaryLedger(boundary, disposition, emittedEnergy, inputEnergy, set);
  const invariantMass = evaluateFourMomentum(pulseSystem, emittedEnergy, set);

  const card = evaluateEnergySourceCard(cardId, set);
  const cards: Record<Me03CardId, EnergySourceCard> = {
    "me-03-card-radium": evaluateEnergySourceCard("me-03-card-radium", set),
    "me-03-card-sun": evaluateEnergySourceCard("me-03-card-sun", set),
    "me-03-card-coal": evaluateEnergySourceCard("me-03-card-coal", set),
    "me-03-card-candle": evaluateEnergySourceCard("me-03-card-candle", set),
    "me-03-card-bulb": evaluateEnergySourceCard("me-03-card-bulb", set),
    "me-03-heated-sealed-box": evaluateEnergySourceCard("me-03-heated-sealed-box", set),
    "me-03-sealed-lamp-and-mirror": evaluateEnergySourceCard("me-03-sealed-lamp-and-mirror", set),
  };

  return Object.freeze({
    boundary,
    disposition,
    emittedEnergy,
    inputEnergy,
    cardId,
    mode,
    pulseSystem,
    speedOfLight: c,
    energyChange: ledger.energyChange,
    massChange: ledger.massChange,
    radiationEnergyChange: ledger.radiationEnergyChange,
    radiationMassChange: ledger.radiationMassChange,
    systemEnergyChange: ledger.systemEnergyChange,
    systemMassChange: ledger.systemMassChange,
    invariantMass,
    card,
    cards: Object.freeze(cards),
    boundaryFacts: card.boundary,
  });
}

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.

evaluatePhotonBox · src/physics/reference/massEnergy.ts · this site’s source, as built · sha256:ec37d2f99b43271a59a00c92d228d4e8112e5bbda87ca7342c0bd29b5650ff8a

This function computes the listed outputs when it runs.

In words

Refuse unless the box mass, box length and pulse energy are positive and finite, and unless the pulse energy is small compared with the box mass times the square of the speed of light. Then the pulse carries momentum equal to its energy divided by the speed of light, the box recoils at that momentum divided by its mass, and while the pulse crosses, the box moves back by the energy times the length divided by the mass times the square of the speed of light. If the light is given the mass of its energy divided by the square of the speed of light, the centre of mass does not move.

Implementation

/**
 * 1906 photon-in-a-box thought experiment (Einstein, Ann. Phys. 20, 627-633).
 * Evaluates the nonrelativistic recoil, pulse flight time, displacement, and center-of-mass shift.
 */
export function evaluatePhotonBox(input: PhotonInBoxInput = {}): PhotonInBoxResult {
  const M = input.M ?? 1.0;
  const ell = input.ell ?? 1.0;
  const E = input.E ?? 1.0;
  const assignLightMass = input.assignLightMass ?? true;
  const domainBound = input.domainBound ?? 1e-3;
  const set = input.set ?? getConstantSet("modern-si-2019");
  const c = constantValue(set, "speedOfLight").value;
  const cSq = c * c;

  const refuse = (reason: string, condition: string): PhotonInBoxResult => {
    return Object.freeze({
      status: "outside-domain" as const,
      condition,
      reason,
      boxMass: asOutside("boxMass", "kg", "box-mass", "massEnergy.box", condition, reason),
      boxLength: asOutside("boxLength", "m", "box-length", "massEnergy.box", condition, reason),
      pulseEnergy: asOutside(
        "emittedEnergyRestFrame",
        "J",
        "emitted-energy",
        "massEnergy.box",
        condition,
        reason,
      ),
      pulseFlightTime: asOutside(
        "pulseFlightTime",
        "s",
        "pulse-flight-time",
        "massEnergy.box",
        condition,
        reason,
      ),
      recoilSpeed: asOutside(
        "recoilSpeed",
        "m/s",
        "recoil-speed",
        "massEnergy.box",
        condition,
        reason,
      ),
      pulseMomentum: asOutside(
        "pulseMomentum",
        "kg·m/s",
        "pulse-momentum",
        "massEnergy.box",
        condition,
        reason,
      ),
      boxDisplacement: asOutside(
        "boxDisplacement",
        "m",
        "box-displacement",
        "massEnergy.box",
        condition,
        reason,
      ),
      centerOfMassShift: asOutside(
        "centerOfMassShift",
        "m",
        "center-of-mass-shift",
        "massEnergy.box",
        condition,
        reason,
      ),
      comShift: Number.NaN,
      displacement: Number.NaN,
      recoilSpeedValue: Number.NaN,
      flightTimeValue: Number.NaN,
      lightMassAssigned: asOutside(
        "lightMassAssigned",
        "kg",
        "light-mass-assigned",
        "massEnergy.box",
        condition,
        reason,
      ),
      domainRatio: Number.isFinite(E) && Number.isFinite(M) && M > 0 ? E / (M * cSq) : Number.NaN,
      domainBound,
      approximations: Object.freeze(["nonrelativistic-box", "flight-time-l-over-c", "rigid-box"]),
      exactRationalCenterOfMassShift: Object.freeze({
        numerator: 0n,
        denominator: 1n,
        isExactlyZero: false,
      }),
    });
  };

  if (![M, ell, E].every(Number.isFinite) || M <= 0 || ell <= 0 || E <= 0) {
    return refuse(
      "Box mass, box length, and pulse energy must be positive and finite.",
      "M > 0, ell > 0, E > 0",
    );
  }

  const domainRatio = E / (M * cSq);
  if (domainRatio > domainBound) {
    return refuse(
      "The nonrelativistic recoil approximation and neglected change in pulse transit time are no longer small when E / (M * c^2) exceeds the declared bound.",
      `E / (M * c^2) <= ${domainBound}`,
    );
  }

  const recoilSpeed = E / (M * c);
  const pulseFlightTime = ell / c;
  const pulseMomentum = E / c;
  const displacement = -(E * ell) / (M * cSq);
  const lightMass = E / cSq;
  const comShift = assignLightMass ? 0 : displacement;

  const rationalShift = (() => {
    if (assignLightMass) {
      return Object.freeze({
        numerator: 0n,
        denominator: 1n,
        isExactlyZero: true,
      });
    }
    const rE = toBigIntRational(E);
    const rEll = toBigIntRational(ell);
    const rM = toBigIntRational(M);
    const cBig = BigInt(Math.round(c));
    const cSqBig = cBig * cBig;

    const num = -(rE.num * rEll.num * rM.den);
    const den = rE.den * rEll.den * rM.num * cSqBig;
    return Object.freeze({
      numerator: num,
      denominator: den,
      isExactlyZero: num === 0n,
    });
  })();

  return Object.freeze({
    status: "value" as const,
    boxMass: asValue("boxMass", "kg", "box-mass", "massEnergy.box", M),
    boxLength: asValue("boxLength", "m", "box-length", "massEnergy.box", ell),
    pulseEnergy: asValue("emittedEnergyRestFrame", "J", "emitted-energy", "massEnergy.box", E),
    pulseFlightTime: asValue(
      "pulseFlightTime",
      "s",
      "pulse-flight-time",
      "massEnergy.box",
      pulseFlightTime,
    ),
    recoilSpeed: asValue("recoilSpeed", "m/s", "recoil-speed", "massEnergy.box", recoilSpeed),
    pulseMomentum: asValue(
      "pulseMomentum",
      "kg·m/s",
      "pulse-momentum",
      "massEnergy.box",
      pulseMomentum,
    ),
    boxDisplacement: asValue(
      "boxDisplacement",
      "m",
      "box-displacement",
      "massEnergy.box",
      displacement,
    ),
    centerOfMassShift: asValue(
      "centerOfMassShift",
      "m",
      "center-of-mass-shift",
      "massEnergy.box",
      comShift,
    ),
    comShift,
    displacement,
    recoilSpeedValue: recoilSpeed,
    flightTimeValue: pulseFlightTime,
    lightMassAssigned: asValue(
      "lightMassAssigned",
      "kg",
      "light-mass-assigned",
      "massEnergy.box",
      assignLightMass ? lightMass : 0,
    ),
    domainRatio,
    domainBound,
    approximations: Object.freeze(["nonrelativistic-box", "flight-time-l-over-c", "rigid-box"]),
    exactRationalCenterOfMassShift: rationalShift,
  });
}

Energy that leaves a body takes mass with it. Draw the boundary around the body alone and it gets lighter; draw it around the body and the light it gave off, and nothing is lost.

The mass–energy paper concludes that a body giving off energy L loses mass L/V², that it does not matter that the energy leaves as radiation, and that, if the theory is right, radiation carries inertia from the body that emits it to the body that absorbs it. The instrument keeps the accounting honest by making you choose where the boundary goes. With 1 J emitted and the boundary around the body alone, the body's energy falls by 1 J and its mass by 1.11 × 10⁻¹⁷ kg. Around the radiation alone, 1 J arrives, and the lab gives it no rest mass in the 1905 account, saying so rather than inventing one. Around the body and its light together, an isolated system, nothing changes. In the four-momentum lens, a modern addition, two opposite pulses of total energy 1 J have an invariant mass of 1.11 × 10⁻¹⁷ kg, which is where the body's lost mass went. The energy-source cards apply ΔE/c² to cited modern transfers: a radium-226 alpha decay of 4.871 MeV changes mass by 8.68 × 10⁻³⁰ kg; the Sun's 3.828 × 10²⁶ W takes away 4.26 × 10⁹ kg each second; a kilogram of coal burned at 30 MJ, 3.34 × 10⁻¹⁰ kg; a candle for an hour, 3.20 × 10⁻¹² kg; a 100 W bulb for a year, 3.51 × 10⁻⁸ kg. In the 1906 photon-in-a-box mode (credit: Poincaré 1900), a pulse crossing a floating box shows that the centre of mass stays put only if the light is given the mass E/c².

Modern qualifications

The 1905 conclusions are conditional. The paper says it is not excluded that bodies whose energy content varies greatly, radium salts for instance, could test the theory, and that if the theory corresponds to the facts, radiation carries inertia between the emitting and absorbing bodies. It gives no rest mass to free radiation; the invariant mass of a system of light belongs to the later four-momentum language. The box is Einstein's 1906 argument (credit: Poincaré 1900): his paper credits Poincaré's remark of 1900 that electromagnetic energy behaves like a fluid with inertia. The energy-source values are modern and cited on each card; none was measured in 1905, and the mass changes of chemical and everyday transfers are far too small to weigh.

The physics of the boundary

Three thermodynamic boundaries

Einstein concludes that if a body gives off the energy L in the form of radiation, its mass diminishes by L/V² (or in modern notation L/c²):

\Delta m = -\frac{L}{c^2}

Explain this equation

The total energy of an isolated system is strictly conserved. If the boundary is drawn around the emitting body and the radiation together inside a sealed container, no energy escapes, and the total mass of the enclosure remains completely unchanged:

\Delta E_{\text{isolated}} = 0 \implies \Delta m_{\text{isolated}} = 0

Closed systems versus isolated systems

A system is closed if no matter crosses its boundary. It is isolated only if neither matter nor energy crosses its boundary. A radioactive radium salt sealed in an ampoule exchanges heat with its surroundings without losing matter; its mass decreases only as that heat leaves the container.

Modern four-momentum invariant mass

In modern relativistic mechanics, the invariant mass m of any system of particles or photons is the Lorentz norm of its total four-momentum P^μ = (E/c, p):

m^2 c^2 = P^\mu P_\mu = \left(\frac{E}{c}\right)^2 - \|\mathbf{p}\|^2

While a single light pulse has |p| = E/c and is therefore massless (m = 0), two equal and opposite light pulses have total momentum p = 0 and carry a nonzero system invariant mass:

m_{\text{two pulses}} = \frac{L}{c^2}

Open the two-ledger laboratory Open the small-speed coefficient laboratory

Before you draw a conclusion

Common wrong turns this instrument speaks to

Mass is converted into energy.
Nothing is used up. The body has less mass because energy left it, and the light that carries the energy carries the inertia with it.
Read the full entry, with its sources
Light has no mass, so it cannot carry mass away.
Two pulses going opposite ways have mass together, though each has none alone. This is a modern way of putting it, and it is not part of the 1905 argument.
Read the full entry, with its sources
Einstein measured the mass change.
The paper reports no measurement. It says only that a test with radium salts is not ruled out.
Read the full entry, with its sources
$E=mc^2$ is about nuclear bombs.
The paper's argument applies to any body that gives off energy. A candle flame loses mass this way too, only very little.
Read the full entry, with its sources
Only light carries this mass; heating a body or storing chemical energy does not change its inertia.
The paper goes beyond light: it concludes that the mass of a body measures its whole energy content, however the energy leaves.
Read the full entry, with its sources

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