Chapter 3: Entropy Production in Urban Systems

3.1 Cities as Dissipative Structures

A city is a paradigmatic example of a dissipative structure: a highly organised, far-from-equilibrium system that maintains its order by continuously dissipating energy and producing entropy. Food, fuel, electricity, and raw materials flow in; waste heat, garbage, sewage, and pollution flow out. Without these flows, the city would decay to equilibrium—ruins.

The thermodynamic framework for such systems was developed by Ilya Prigogine and collaborators, culminating in the Glansdorff-Prigogine stability theory. In this chapter we apply their formalism to urban metabolism.

3.2 The Entropy Balance Equation

The total entropy $S$ of an open system changes due to two contributions:

$$\frac{dS}{dt} = \frac{d_e S}{dt} + \frac{d_i S}{dt}$$

• $d_e S / dt$: entropy exchange with the environment (can be positive or negative)
• $d_i S / dt$: internal entropy production from irreversible processes

The second law of thermodynamics demands:

$$\frac{d_i S}{dt} \geq 0 \qquad \text{(always)}$$

For a city at steady state, $dS/dt = 0$, so:

$$\frac{d_e S}{dt} = -\frac{d_i S}{dt} < 0$$

The city must export entropy to its environment at exactly the rate it produces it internally. This is the thermodynamic cost of urban order.

3.3 Local Entropy Production Rate

The internal entropy production rate density$\sigma$ is the sum over all irreversible processes, each characterised by a thermodynamic flux$J_k$ and its conjugate force$X_k$:

$$\sigma = \sum_k J_k \, X_k \geq 0$$

Urban Irreversible Processes

In an urban context, the major entropy-producing processes include:

Process	Flux $J_k$	Force $X_k$
Heat dissipation	Heat flux $\mathbf{J}_q$	$\nabla(1/T)$
Material transport	Mass flux $\mathbf{J}_m$	$-\nabla(\mu/T)$
Chemical reactions	Reaction rate $w_r$	Affinity $A_r / T$
Traffic friction	Vehicle flow $\mathbf{J}_v$	Velocity gradient $-\nabla v / T$

Onsager Linear Regime

Near equilibrium, fluxes are linear functions of forces (Onsager reciprocal relations):

$$J_k = \sum_j L_{kj} X_j, \qquad L_{kj} = L_{jk}$$

The entropy production then becomes a quadratic form:

$$\sigma = \sum_{k,j} L_{kj} X_k X_j \geq 0$$

This requires the Onsager matrix $\mathbf{L}$ to be positive semi-definite.

3.4 Prigogine’s Minimum Entropy Production Theorem

Prigogine showed that in the linear regime, when some forces are held fixed by boundary conditions while others are free, the system evolves to a steady state that minimises the total entropy production rate:

$$\frac{d}{dt}\left(\frac{d_i S}{dt}\right) \leq 0 \qquad \text{(in the linear regime)}$$

Urban interpretation: a city in the linear regime (small perturbations from steady state) will self-organise toward the least wasteful configuration compatible with its boundary conditions (population, resource inflows, climate). This provides a variational principle for urban form.

Proof Sketch

The total entropy production is:

$$P = \int_V \sigma \, dV = \int_V \sum_{k,j} L_{kj} X_k X_j \, dV$$

The time derivative splits into two parts (Glansdorff-Prigogine decomposition):

$$\frac{dP}{dt} = \underbrace{\sum_k \int_V J_k \frac{\partial X_k}{\partial t} dV}_{d_X P} + \underbrace{\sum_k \int_V X_k \frac{\partial J_k}{\partial t} dV}_{d_J P}$$

In the linear regime with constant $L_{kj}$, both terms equal $dP/2dt$, and the Euler-Lagrange equations for the free forces give $d_X P \leq 0$. The key insight is that $d_X P$ acts as a Lyapunov function, guaranteeing stability of the steady state.

3.5 Far-from-Equilibrium: Symmetry Breaking

Real cities operate far from equilibrium, where the Onsager linear approximation breaks down. In this regime, the minimum entropy production theorem no longer holds, and the system can undergosymmetry-breaking bifurcations to new ordered states.

The Glansdorff-Prigogine stability criterion states that a non-equilibrium steady state is stable if:

$$\delta^2 \left(\frac{d_i S}{dt}\right) = \sum_k \delta J_k \, \delta X_k > 0$$

When this second variation becomes negative, the steady state is unstable and the city transitions to a qualitatively new regime—analogous to phase transitions. Urban examples include:

• Sudden gentrification waves
• Traffic congestion phase transitions
• Emergence of new commercial centres
• Industrial collapse and rust-belt formation

3.6 Python: Urban Entropy Production

We compute the entropy production rate for a simple urban metabolism model with heat dissipation, material transport, and chemical waste processing.

Entropy Production & Prigogine Stability

Python

script.py84 lines

import numpy as np

# ── Urban Metabolism Entropy Production ──
# Three coupled irreversible processes

# Onsager coefficients (symmetric, positive definite)
L = np.array([
    [2.5, 0.3, 0.1],   # heat-heat, heat-mass, heat-chem
    [0.3, 1.8, 0.2],   # mass-heat, mass-mass, mass-chem
    [0.1, 0.2, 1.2],   # chem-heat, chem-mass, chem-chem
])

print("=" * 58)
print("  Urban Entropy Production: Glansdorff-Prigogine Analysis")
print("=" * 58)

# Verify positive definiteness
eigvals = np.linalg.eigvalsh(L)
print(f"  Onsager matrix eigenvalues: {eigvals}")
print(f"  Positive definite: {all(e > 0 for e in eigvals)}")
print()

# Thermodynamic forces for different city sizes
# Forces decrease as city optimizes (larger cities more efficient)
populations = [1e5, 5e5, 1e6, 5e6, 1e7]
print(f"  {'Population':>12} {'sigma_heat':>12} {'sigma_mass':>12} {'sigma_chem':>12} {'sigma_total':>12} {'Per capita':>12}")
print("-" * 78)

for N in populations:
    # Forces scale with population: X ~ N^alpha
    # Heat: T gradient driven by energy use ~ N^0.75 over area ~ N^0.67
    X_heat = 0.5 * (N / 1e6)**0.08   # weakly increasing
    X_mass = 0.3 * (N / 1e6)**(-0.05) # slightly decreasing (efficiency)
    X_chem = 0.2 * (N / 1e6)**0.03    # nearly constant
    X = np.array([X_heat, X_mass, X_chem])

# Fluxes: J = L @ X
    J = L @ X

# Entropy production: sigma = J . X = X^T L X
    sigma_components = J * X
    sigma_total = np.sum(sigma_components)
    sigma_per_cap = sigma_total / N * 1e6  # per million people

print(f"  {N:12.0f} {sigma_components[0]:12.4f} {sigma_components[1]:12.4f} "
          f"{sigma_components[2]:12.4f} {sigma_total:12.4f} {sigma_per_cap:12.6f}")

print()
print("  Key insight: per-capita entropy production DECREASES with city size")
print("  => Larger cities are thermodynamically more efficient")
print("  => Consistent with sublinear infrastructure scaling (beta = 3/4)")
print()

# Stability check: Glansdorff-Prigogine criterion
print("  Stability Analysis (delta^2 sigma > 0 for stability):")
# Small perturbation to forces
delta_X = np.array([0.01, -0.005, 0.008])
delta_J = L @ delta_X
delta2_sigma = np.dot(delta_J, delta_X)
print(f"  Perturbation delta_X = {delta_X}")
print(f"  delta^2(sigma) = {delta2_sigma:.6f}")
print(f"  Steady state is {'STABLE' if delta2_sigma > 0 else 'UNSTABLE'}")
print()

# Time evolution toward minimum entropy production
print("  Time evolution of entropy production (Prigogine theorem):")
X_t = np.array([0.8, 0.6, 0.4])  # initial far from steady state
dt = 0.05
sigmas = []
for step in range(20):
    J_t = L @ X_t
    sigma = np.dot(J_t, X_t)
    sigmas.append(sigma)
    # Relax free forces toward minimum (gradient descent on sigma)
    grad = 2 * L @ X_t
    X_t = X_t - 0.02 * grad  # only free components relax
    X_t = np.maximum(X_t, 0.01)  # physical lower bound

print(f"  {'Step':>6} {'sigma':>12}")
for i, s in enumerate(sigmas):
    bar = '#' * int(s * 20)
    print(f"  {i:6d} {s:12.4f}  {bar}")
print()
print("  sigma decreases monotonically => minimum entropy production at steady state")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

3.7 Fortran: Entropy Production Rate

A Fortran implementation computing entropy production for an urban system with coupled thermodynamic fluxes.

Fortran: Entropy Production Rate

Fortran

program.f9074 lines

program entropy_production
  implicit none
  integer, parameter :: n_proc = 3
  real(8) :: L(n_proc, n_proc), X(n_proc), J(n_proc)
  real(8) :: sigma, sigma_k
  integer :: k, j_idx, step
  real(8) :: grad(n_proc)

! Onsager coefficients
  L(1,:) = (/ 2.5d0, 0.3d0, 0.1d0 /)
  L(2,:) = (/ 0.3d0, 1.8d0, 0.2d0 /)
  L(3,:) = (/ 0.1d0, 0.2d0, 1.2d0 /)

! Initial thermodynamic forces
  X = (/ 0.5d0, 0.3d0, 0.2d0 /)

write(*,'(A)') '============================================='
  write(*,'(A)') '  Fortran Entropy Production Calculator'
  write(*,'(A)') '============================================='

! Compute fluxes J = L * X
  do k = 1, n_proc
    J(k) = 0.0d0
    do j_idx = 1, n_proc
      J(k) = J(k) + L(k, j_idx) * X(j_idx)
    end do
  end do

! Compute entropy production sigma = sum(J_k * X_k)
  sigma = 0.0d0
  do k = 1, n_proc
    sigma_k = J(k) * X(k)
    sigma = sigma + sigma_k
    write(*,'(A,I1,A,F10.6)') '  Process ', k, ' contribution: ', sigma_k
  end do

write(*,'(A,F10.6)') '  Total sigma = ', sigma
  write(*,'(A)')       '---------------------------------------------'

! Relaxation toward min entropy production
  write(*,'(A)') '  Relaxation to steady state:'
  write(*,'(A)') '  Step     sigma'

X = (/ 0.8d0, 0.6d0, 0.4d0 /)  ! far from steady state
  do step = 1, 15
    ! Compute J and sigma
    sigma = 0.0d0
    do k = 1, n_proc
      J(k) = 0.0d0
      do j_idx = 1, n_proc
        J(k) = J(k) + L(k, j_idx) * X(j_idx)
      end do
      sigma = sigma + J(k) * X(k)
    end do
    write(*,'(I6,F12.6)') step, sigma

! Gradient descent on sigma
    do k = 1, n_proc
      grad(k) = 0.0d0
      do j_idx = 1, n_proc
        grad(k) = grad(k) + 2.0d0 * L(k, j_idx) * X(j_idx)
      end do
    end do
    do k = 1, n_proc
      X(k) = X(k) - 0.02d0 * grad(k)
      if (X(k) < 0.01d0) X(k) = 0.01d0
    end do
  end do

write(*,'(A)') '============================================='
  write(*,'(A)') '  sigma decreases => Prigogine theorem holds'
  write(*,'(A)') '============================================='

end program entropy_production

Click Run to execute the Fortran code

Code will be compiled with gfortran and executed on the server

3.8 Summary & Key Takeaways

• Cities are dissipative structures: they maintain order by exporting entropy
• Entropy production rate: $\sigma = \sum_k J_k X_k \geq 0$
• In the linear regime, Prigogine’s theorem guarantees evolution toward minimum entropy production
• Far from equilibrium, the Glansdorff-Prigogine criterion predicts instability and phase transitions
• Per-capita entropy production decreases with city size, consistent with sublinear infrastructure scaling

← Social Superlinearity Next: Logistic ODE →

Process	Flux \(J_k\)	Force \(X_k\)
Heat dissipation	Heat flux \(\mathbf{J}_q\)	\(\nabla(1/T)\)
Material transport	Mass flux \(\mathbf{J}_m\)	\(-\nabla(\mu/T)\)
Chemical reactions	Reaction rate \(w_r\)	Affinity \(A_r / T\)
Traffic friction	Vehicle flow \(\mathbf{J}_v\)	Velocity gradient \(-\nabla v / T\)