Chemistry · Introductory

First-order reaction kinetics

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

In a first-order reaction, the rate is directly proportional to the concentration of one reactant, so the concentration falls exponentially with time. The rate constant k sets the speed, and the half-life is constant, independent of starting concentration.

Intuition

Imagine a crowd of molecules, each with the same fixed chance per second of reacting, regardless of how many other molecules are around. When there are many molecules, many react each second; as they get used up, fewer react, so the rate slows down in proportion. This is the same logic as radioactive decay or drug elimination from the blood. Because each molecule acts independently, the time for half to disappear is always the same: after one half-life half remain, after two a quarter, and so on. Plotting the natural log of concentration against time gives a straight line whose slope is minus k.

Key equations

rate=−d[A]dt=k[A]
(1)

Rate law: rate is proportional to the first power of the concentration of A; k has units of 1/time.

[A]=[A]0e−kt
(2)

Integrated form: concentration decays exponentially from the initial value.

ln⁡[A]=ln⁡[A]0−kt
(3)

Linear form: a plot of ln[A] against t is a straight line with slope -k.

t1/2=ln⁡2k≈0.693k
(4)

Half-life is constant and independent of [A]_0.

Derivation

  1. Start with the rate law: d[A]/dt = -k[A].
  2. Separate variables: d[A]/[A] = -k dt.
  3. Integrate from time 0 to t, and from [A]_0 to [A]: ln[A] - ln[A]_0 = -kt.
  4. Rearrange to get ln[A] = ln[A]_0 - kt, a straight line in t.
  5. Exponentiate both sides: [A] = [A]_0 e^{-kt}.
  6. For the half-life set [A] = [A]_0/2: 1/2 = e^{-k t_half}, so ln 2 = k t_half, giving t_half = ln2 / k.

Worked example

Problem

A drug breaks down in solution by a first-order process with k = 0.0231 per hour. Starting at 80 mg/L, find the half-life and the concentration after 48 hours.

  1. Half-life: t_half = 0.693 / 0.0231 = 30 hours.
  2. Use [A] = [A]_0 e^{-kt} with kt = 0.0231 x 48 = 1.109.
  3. e^{-1.109} is about 0.330.
  4. [A] = 80 x 0.330 = 26.4 mg/L.
  5. Check: 48 h is 1.6 half-lives, so the fraction left is 0.5^1.6, about 0.33. Consistent.

Answer Half-life is 30 hours; concentration after 48 hours is about 26 mg/L.

Common mistakes

  • Thinking the half-life shrinks or grows as the reaction proceeds; for first order it is constant.
  • Forgetting the units of k: first order is per time (for example s^-1), not mol L^-1 s^-1.
  • Plotting [A] against t and expecting a line; the straight line needs ln[A].
  • Using log base 10 with the natural-log formulas without converting.
  • Assuming reaction order can be read from the balanced equation rather than measured experimentally.
  • Confusing rate with rate constant: the rate changes over time, k does not (at fixed temperature).

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(116 lines)
import sys
import numpy as np
from manim import *
from blocks import *


def simulate(k, c0, t_max, dt=0.01):
    """First-order decay: C(t) = C0 * exp(-k*t). Returns t, C arrays."""
    n = int(t_max / dt)
    t = np.linspace(0, t_max, n + 1)
    c = c0 * np.exp(-k * t)
    return t, c


K, C0, T_MAX = 0.5, 1.0, 10.0
TRACE = simulate(K, C0, T_MAX)


class Main(Scene):
    def construct(self):
        TitleCard(self, "First-Order Kinetics", "Concentration decay over time")

        # Compute half-life for caption
        t_half = np.log(2) / K

        # Setup plot
        plot = CurvePlot(
            lambda t: 0,  # placeholder
            x_range=(0, T_MAX, 2),
            y_range=(0, C0 + 0.1, 0.2),
            x_label="Time (s)",
            y_label="Concentration (M)",
            color=C_MAIN,
            x_length=8.0,
            y_length=4.5
        )
        plot.shift(DOWN * 0.2)
        
        # Draw axes first
        self.play(Create(plot.axes), FadeIn(plot.labels), run_time=1.5)
        
        # Equation
        eq = MathTex(r"C(t) = C_0 e^{-kt}", font_size=36, color=C_ACCENT)
        eq.to_edge(UP, buff=0.5).shift(LEFT * 3)
        self.play(Write(eq), run_time=1)

        # Animate the curve growing
        # We use a ValueTracker to draw the curve progressively
        tracker = ValueTracker(0)
        
        # Create the full curve object but make it invisible initially
        full_curve = plot.axes.plot(
            lambda t: C0 * np.exp(-K * t),
            x_range=[0, T_MAX],
            color=C_MAIN
        )
        self.add(full_curve)
        
        # Use a clip group to reveal the curve
        clip_group = VGroup()
        clip_group.add(full_curve)
        
        # Define a function that updates the visible part of the curve
        # Actually, simpler: just animate the creation of the curve using the tracker to limit the domain?
        # Manim's Create animation works on the whole object. 
        # Better approach for "sim": draw the curve, then highlight points or use a mask.
        # Let's use a mask group.
        
        mask = Rectangle(
            width=0, 
            height=plot.axes.get_height() + 1, 
            fill_color=BLACK, 
            fill_opacity=1,
            stroke_width=0
        )
        mask.move_to(plot.axes.c2p(T_MAX/2, 0)) # Center it initially? No, let's slide it.
        # FIX: Use plot.axes.x_axis.get_length() instead of non-existent x_scale
        mask.set_x(-plot.axes.x_axis.get_length() / 2) # Start off-screen left
        
        # Actually, let's just animate the curve drawing. It's standard.
        self.play(Create(full_curve), run_time=4, rate_func=linear)
        
        # Highlight half-life point
        half_x = plot.axes.c2p(t_half, C0 * np.exp(-K * t_half))
        dot = Dot(half_x, color=C_BAD, radius=0.1)
        line_v = DashedLine(
            start=plot.axes.c2p(t_half, 0),
            end=half_x,
            color=C_DIM
        )
        line_h = DashedLine(
            start=plot.axes.c2p(0, C0 * np.exp(-K * t_half)),
            end=half_x,
            color=C_DIM
        )
        
        self.play(FadeIn(dot), Create(line_v), Create(line_h), run_time=1.5)
        
        caption_text = f"Half-life: t_{{1/2}} = ln(2)/k \\approx {t_half:.2f} s"
        StepCaption(self, caption_text)
        
        self.wait(2)


if __name__ == "__main__" and "--selftest" in sys.argv:
    t, c = TRACE
    # Check initial condition
    assert abs(c[0] - C0) < 1e-9
    # Check decay behavior
    assert c[-1] < c[0]
    # Check half-life calculation
    t_half_calc = np.log(2) / K
    # Find closest time point to half-life
    idx = np.argmin(np.abs(t - t_half_calc))
    assert abs(c[idx] - C0 / 2) < 0.05 # Approximate match due to discrete steps
    print("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.