Chapter 14: Landauer's Principle

Part V: Information & Physics

The Principle

$ W_{\min} = k_B T \ln 2 $

Minimum work required to erase one bit of information at temperature $T$

Rolf Landauer (1961) at IBM established that logically irreversible operations — specifically, erasing a bit (resetting a memory register to a known state) — must dissipate at least $k_B T \ln 2 \approx 2.85 \times 10^{-21}$ joules as heat at room temperature.

At 300 K, this equals about 2.85 zeptojoules (zJ)— an almost inconceivably small amount, yet it places a fundamental limit on the energy efficiency of computation.

Thermodynamic Derivation

A bit can be in one of two equiprobable states. The associated Shannon entropy is:

$ H = k_B \ln 2 \quad \text{(1 bit of thermodynamic entropy)} $

Erasing this bit (mapping both states to a single known state, e.g., "0") reduces the system entropy by $k_B \ln 2$. By the second law of thermodynamics, the environment must absorb at least this much entropy:

$ \Delta S_{\text{env}} \geq k_B \ln 2 $

$ Q_{\text{dissipated}} = T \Delta S_{\text{env}} \geq k_B T \ln 2 $

The logical operation of erasure — a many-to-one mapping — is the source of irreversibility. The minimum heat dissipated equals the work that would have been extractable from the information had it been used in a thermodynamic process.

Experimental Verification (2012)

For 50 years, Landauer's principle remained theoretical. In 2012, Bérut et al. (Nature, 483, 187–190) directly measured the heat dissipated during a single bit erasure using a colloidal particle in a double-well optical trap.

A silica bead (2 μm diameter) trapped in a laser-created double well represents a 1-bit memory.
Erasure is performed by tilting the potential and then restoring it — the bead ends in one well regardless of initial position.
Heat dissipated was measured via the Jarzynski equality from fluctuation theorems.
Result: $\langle Q \rangle \geq k_B T \ln 2$ confirmed within experimental error.

This experiment confirmed that the Landauer limit is a physical reality, not just a theoretical bound — with precise agreement at the zeptojoule scale.

Reversible Computing

Bennett (1973) showed that any computation can be performed reversibly — using only logically reversible gates — at zero thermodynamic cost (in principle), by keeping a copy of all intermediate results.

Fredkin Gate (conservative)

A universal 3-input, 3-output gate. Every input bit maps to a unique output bit. No information is lost — in principle, zero heat dissipation.

Toffoli Gate

Controlled-controlled-NOT: reversible, universal for classical computation. Forms the basis of quantum gate implementations with zero classical dissipation.

In practice, erasure occurs at memory cleanup, I/O operations, and garbage collection. Current CPUs dissipate roughly $10^5 \times$ the Landauer limit per operation; future designs must approach this bound as transistors shrink further.

Python: Landauer Limit & Moore's Law Convergence

Plot the minimum erasure energy vs temperature, compare historical CPU energy consumption with the Landauer limit, and show energies at key operating temperatures.

Python

script.py102 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

kB = 1.380649e-23   # J/K  (Boltzmann constant)

# ── Panel 1: Landauer limit vs temperature ──────────────────────────────────
T_range = np.linspace(1, 1000, 500)   # Kelvin
E_landauer = kB * T_range * np.log(2)  # J per bit erasure

# ── Panel 2: Historical computer energy per bit vs Landauer limit ────────────
# Data: approximate energy/bit for landmark CPUs (year, energy_J_per_bit)
# Sources: historical estimates (orders of magnitude)
historical_years  = np.array([1950, 1960, 1970, 1980, 1990, 2000, 2010, 2020, 2025])
historical_energy = np.array([1e-1, 1e-3, 1e-5, 1e-7, 1e-9, 1e-11, 1e-13, 1e-15, 3e-16])  # J/bit

T_room = 300.0  # K
landauer_room = kB * T_room * np.log(2)  # ~2.85e-21 J

# Project Landauer limit horizontally across time
years_proj = np.array([1950, 2030])
landauer_line = np.array([landauer_room, landauer_room])

print("=== Landauer's Principle ===")
print(f"Minimum energy to erase 1 bit at room temperature (T={T_room} K):")
print(f"  E_min = kB * T * ln(2) = {landauer_room:.4e} J = {landauer_room*1e21:.3f} zJ")
print()
print("Historical CPU energy per bit:")
for y, e in zip(historical_years, historical_energy):
    ratio = e / landauer_room
    print(f"  {y}: {e:.2e} J/bit  ({ratio:.1e}x Landauer limit)")
print()
print(f"2025 estimate: ~{historical_energy[-1]:.1e} J/bit ({historical_energy[-1]/landauer_room:.0f}x Landauer)")
print(f"Landauer limit: {landauer_room:.3e} J/bit")
print()

# ── Panel 3: Reversible vs irreversible gate energy ──────────────────────────
T_vals  = np.array([1, 4, 77, 300, 600])   # K (LHe, LN2, room, hot chip, oven)
labels  = ['1 K\n(quantum)', '4 K\n(LHe)', '77 K\n(LN2)', '300 K\n(room)', '600 K\n(hot)']
E_min   = kB * T_vals * np.log(2) * 1e21   # zJ

print("Landauer limit at key temperatures:")
for t, e in zip(T_vals, E_min):
    print(f"  T = {t:5.0f} K: E_min = {e:.4f} zJ")

# ── Plotting ──────────────────────────────────────────────────────────────────
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
fig.patch.set_facecolor('#0a0a1a')

# Plot 1: Landauer energy vs temperature
ax1 = axes[0]
ax1.plot(T_range, E_landauer * 1e21, color='#818cf8', linewidth=2.5, label='$E_{min} = k_B T \ln 2$')
ax1.axvline(300, color='#fbbf24', linestyle='--', linewidth=1.5, alpha=0.8, label='Room temp (300 K)')
ax1.axvline(4,   color='#34d399', linestyle='--', linewidth=1.5, alpha=0.8, label='Liquid He (4 K)')
ax1.set_xlabel('Temperature (K)', color='white', fontsize=11)
ax1.set_ylabel('Minimum erasure energy (zJ = 10⁻²¹ J)', color='white', fontsize=10)
ax1.set_title("Landauer Limit vs Temperature", color='white', fontsize=12, fontweight='bold')
ax1.legend(fontsize=9, facecolor='#1a1a2e', edgecolor='#818cf8', labelcolor='white')
ax1.set_facecolor('#0a0a1a')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.2, color='#818cf8')
for sp in ax1.spines.values(): sp.set_color('#818cf8')

# Plot 2: Historical CPU energy vs Landauer limit
ax2 = axes[1]
ax2.semilogy(historical_years, historical_energy, 'o-', color='#a5b4fc', linewidth=2,
             markersize=6, label='CPU energy per bit op')
ax2.semilogy(years_proj, landauer_line, '--', color='#f87171', linewidth=2.5,
             label=f'Landauer limit (T=300K)\n= {landauer_room:.2e} J')
ax2.fill_between([1950, 2030], landauer_room*0.01, landauer_room,
                 color='#f87171', alpha=0.08, label='Below Landauer (impossible)')
ax2.set_xlabel('Year', color='white', fontsize=11)
ax2.set_ylabel('Energy per bit operation (J)', color='white', fontsize=11)
ax2.set_title("CPU Energy vs Landauer Limit\n(Moore\'s Law Convergence)", color='white', fontsize=12, fontweight='bold')
ax2.legend(fontsize=8, facecolor='#1a1a2e', edgecolor='#818cf8', labelcolor='white')
ax2.set_xlim(1948, 2032)
ax2.set_ylim(1e-22, 1e1)
ax2.set_facecolor('#0a0a1a')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.2, color='#818cf8')
for sp in ax2.spines.values(): sp.set_color('#818cf8')

# Plot 3: Landauer energy at key temperatures
ax3 = axes[2]
bars = ax3.bar(labels, E_min, color='#818cf8', alpha=0.85, edgecolor='white', linewidth=0.8)
ax3.set_ylabel('Minimum erasure energy (zJ)', color='white', fontsize=11)
ax3.set_title("Landauer Limit at Key Temperatures", color='white', fontsize=12, fontweight='bold')
ax3.set_facecolor('#0a0a1a')
ax3.tick_params(colors='white')
ax3.grid(True, alpha=0.2, color='#818cf8', axis='y')
for sp in ax3.spines.values(): sp.set_color('#818cf8')
for bar, e in zip(bars, E_min):
    ax3.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.002,
             f'{e:.4f}', ha='center', va='bottom', color='white', fontsize=8)

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a1a')
plt.show()
print("\nReversible computing (Fredkin/Toffoli gates) can approach but not reach Landauer limit.")
print("Experimental verification: Bérut et al., Nature 2012 confirmed kT ln2 at T=300K.")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Ch 13: Maxwell's Demon Ch 15: Black Hole Information →