Physics · Intermediate

Radioactive decay chain

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

A radioactive decay chain occurs when a parent nuclide decays into a daughter that is itself radioactive, continuing until a stable nuclide is reached. The amounts of each member follow coupled rate equations (the Bateman equations). When the parent outlives the daughter, the chain approaches secular or transient equilibrium, which is the basis of medical generators such as Mo-99/Tc-99m.

Intuition

Picture a series of connected buckets with holes. The top bucket (parent) drains into the second (daughter), which drains into a third. Each bucket loses water at a rate proportional to how full it is, and the size of the hole is the decay constant. The daughter bucket is fed by the parent while it drains itself. At first the daughter is empty and fills; later the inflow and outflow balance. If the parent drains slowly compared with the daughter, the daughter level tracks the parent, and the two activities settle into a fixed ratio. If the parent is much longer-lived, the activities become nearly equal. That is why a technetium generator can be milked repeatedly: Tc-99m is continually regrown from Mo-99.

Key equations

dN1dt=−λ1N1
(1)

The parent decays exponentially at a rate proportional to its number of atoms.

dN2dt=λ1N1−λ2N2
(2)

The daughter is produced by the parent and lost by its own decay.

N2(t)=λ1λ2−λ1N1(0)(e−λ1t−e−λ2t)
(3)

Daughter population when N2(0)=0 (Bateman solution).

A2A1=λ2λ2−λ1
(4)

Activity ratio in transient equilibrium (λ1<λ2, long times).

tmax=ln⁡(λ2/λ1)λ2−λ1
(5)

Time at which the daughter population peaks.

Derivation

  1. Start with the parent: dN1dt=−λ1N1, giving N1=N1(0)e−λ1t.
  2. Write the daughter equation: dN2dt+λ2N2=λ1N1(0)e−λ1t.
  3. Multiply by the integrating factor e^{λ2 t}: d(N2 e^{λ2 t})/dt = λ1 N1(0) e^{(λ2-λ1)t}.
  4. Integrate from 0 to t with N2(0)=0: N2 e^{λ2 t} = λ1 N1(0)(e^{(λ2-λ1)t}-1)/(λ2-λ1).
  5. Multiply by e^{-λ2 t} to get the Bateman result N2 = λ1 N1(0)(e^{-λ1 t}-e^{-λ2 t})/(λ2-λ1).
  6. For λ2>λ1 and large t, e^{-λ2 t} is negligible, so N2 ≈ λ1 N1/(λ2-λ1), and A2/A1 = λ2/(λ2-λ1).
  7. If λ2 >> λ1 this ratio tends to 1: secular equilibrium, A2 ≈ A1.

Worked example

Problem

Mo-99 (half-life 66 h) decays to Tc-99m (half-life 6 h). In a freshly eluted generator, at what time does Tc-99m activity peak, and what is the activity ratio A(Tc)/A(Mo) at that time and at long times (ignore the branching fraction)?

  1. λ1 = ln2/66 = 0.0105 h^-1; λ2 = ln2/6 = 0.1155 h^-1.
  2. t_max = ln(λ2/λ1)/(λ2-λ1) = ln(11)/(0.105) = 2.398/0.105 ≈ 22.8 h.
  3. At t_max the daughter activity equals the parent activity (A2 = A1), so the ratio is 1.
  4. At long times, A2/A1 = λ2/(λ2-λ1) = 0.1155/0.105 ≈ 1.10.

Answer Peak at about 23 h, where the activities are equal (ratio 1); at long times the ratio settles near 1.1.

Common mistakes

  • Assuming the daughter's activity always equals the parent's; this holds only at the peak or in secular equilibrium.
  • Using half-lives instead of decay constants in the Bateman formula.
  • Applying equilibrium formulas when the daughter is longer-lived than the parent (no equilibrium is reached).
  • Confusing number of atoms N with activity A = λN.
  • Forgetting that the daughter starts at zero in the standard solution.

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(80 lines)
import sys
from manim import *
from blocks import *
import numpy as np


def simulate(lam1=0.5, lam2=0.2, n0=1.0, dt=0.01, t_end=12.0):
    """Euler simulation of A -> B -> C with a fixed step; returns the recorded states."""
    steps = int(round(t_end / dt))
    ts, A, B, C = [0.0], [n0], [0.0], [0.0]
    for _ in range(steps):
        a, b, c = A[-1], B[-1], C[-1]
        da = -lam1 * a
        db = lam1 * a - lam2 * b
        dc = lam2 * b
        A.append(a + dt * da)
        B.append(b + dt * db)
        C.append(c + dt * dc)
        ts.append(ts[-1] + dt)
    return np.array(ts), np.array(A), np.array(B), np.array(C)


LAM1, LAM2 = 0.5, 0.2
TS, A, B, C = simulate(LAM1, LAM2)


class Main(Scene):
    def construct(self):
        # Title
        TitleCard(self, "Radioactive decay chain", "A \u2192 B \u2192 C")

        # Plot built from the computed arrays
        plot = CurvePlot(lambda x: 0, x_range=(0, 12, 2), y_range=(0, 1, 0.5),
                         x_label="time", y_label="amount", x_length=8, y_length=4.2)
        plot.remove(plot.curve)
        plot.shift(UP * 0.1 + LEFT * 1.5)
        self.play(Create(plot.axes), FadeIn(plot.labels))

        idx = np.arange(0, len(TS), 5)
        colors = [C_BAD, C_ACCENT, C_GOOD]
        names = ["A (parent)", "B (daughter)", "C (stable)"]
        curves = []
        for data, col in zip([A, B, C], colors):
            pts = [plot.axes.c2p(TS[i], data[i]) for i in idx]
            m = VMobject(color=col, stroke_width=4)
            m.set_points_as_corners(pts)
            curves.append(m)

        # Legend
        legend = VGroup(*[
            Text(n, font_size=24, color=c) for n, c in zip(names, colors)
        ]).arrange(DOWN, aligned_edge=LEFT, buff=0.2)
        legend.to_edge(RIGHT, buff=0.6).shift(UP * 0.5)
        self.play(FadeIn(legend))

        # Draw the three simulated curves
        self.play(*[Create(c) for c in curves], run_time=5, rate_func=linear)

        # Mark the peak of B
        k = int(np.argmax(B))
        dot = Dot(plot.axes.c2p(TS[k], B[k]), color=WHITE, radius=0.09)
        lab = Text("B peaks", font_size=24, color=WHITE).next_to(dot, UP, buff=0.15)
        self.play(FadeIn(dot), FadeIn(lab))
        self.wait(1)

        StepCaption(self, "Parent decays, daughter peaks, then the stable product takes over.")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(A[0] - 1.0) < 1e-12 and B[0] == 0 and C[0] == 0
    assert np.allclose(A + B + C, 1.0, atol=1e-9)
    exact_a = np.exp(-LAM1 * TS[-1])
    assert abs(A[-1] - exact_a) < 0.01
    exact_b = LAM1 / (LAM2 - LAM1) * (np.exp(-LAM1 * TS) - np.exp(-LAM2 * TS))
    assert np.max(np.abs(B - exact_b)) < 0.01
    tpk = TS[int(np.argmax(B))]
    assert abs(tpk - np.log(LAM1 / LAM2) / (LAM1 - LAM2)) < 0.1
    assert C[-1] > 0.7
    print("selftest ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.